mbeditor 0.12.8 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f4e31cf2770935dab538488ed3b946b26c7bacfb8519a7d1069cd84d8064838
-  data.tar.gz: db294fee8ac1938dc03f58d0332e13c2da4c8f2a322c62a22fbcd859b8d3b17c
+  metadata.gz: b65424322b66f78929de0629db6e4644a76467e889adaee77121b8c52e0e50de
+  data.tar.gz: 53cd7724f2a80011d474a9616bdb35d88859ddf797a0fa51d3657740038624bd
 SHA512:
-  metadata.gz: d3d8769779acc2c71a535c2d324385f182937a117218471f42dccac8ebe10c0e0741b46da229d3f388c70d8f10c27e510ae25c0eb6e8507dc7967c6e694c46d6
-  data.tar.gz: 130c85228b63ab45775d542086a7bb3104515cf07ecf15e88c8c23e8fe79f42207c9c1ab1f2f3ee16bf611a712c599335d5074e2060d1da90ac37dc52b833b09
+  metadata.gz: f4470580292e46d6de7eb2e3687193452bfbcbee5d478e48c6460e22739fd2942d1a525b04e6d3f7877175db5d18da86c3241032dfc748ca91bf62f0f008cd90
+  data.tar.gz: 05e4226ce7151a7e72d18f34018c30acc04adfbaea235a891afe12ecadb52170b1b598820ea7de326068eae7bb7811cce13ec5cf42b0c69fd6c77683c3b7c819

data/CHANGELOG.md

@@ -7,6 +7,213 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-08-20
+
+### Added
+- **Whole-suite test run, in a drawer.** `POST /test_all` runs the suite with
+  no file argument under its own `test_all_timeout` (30 min) — a suite run is
+  minutes, not seconds, and forcing `test_timeout` up to cover it would let one
+  hung example block for half an hour. It renders as a bottom drawer beside
+  Problems and the log rather than a modal: a backdrop that blocks the editor
+  for the length of a suite run turns the wait into dead time. Failures group
+  by file, each row jumps to its line, and "Open failing" opens them all at
+  once. The result survives closing the drawer and a reload, and a branch
+  switch drops it.
+- **Whole-workspace RuboCop run in the Problems panel.** The panel could only
+  ever show diagnostics for files Monaco had open, because markers are
+  per-model. Three buttons now cover the rest of the project: RuboCop (a full
+  `rubocop --format json` run), Fix (`-a`, safe corrections only), and Open all.
+
+### Changed
+- **Activity bar and explorer are larger.** Activity buttons go 36px to 60px
+  with a 25px glyph and fill the bar edge to edge, so the active indicator sits
+  flush at the screen edge; state is carried by glyph colour alone and the
+  hover box is gone. Explorer rows and icons go 12px to 14px.
+- **Per-file test timeout raised 60s to 180s**, and the client now derives its
+  request timeout from the server's (`/workspace` reports both ceilings)
+  instead of a hard-coded 120s. Raising the server timeout past the client's
+  used to make the browser abort a run the server was still executing.
+
+### Security
+- **Every entry point is gated on `allowed_environments`.** The check moved to
+  `ApplicationController` ahead of `run_authentication`. `LogsController`
+  declared no gate at all, so `GET /mbeditor/logs/tail` returned the tail of
+  `log/<env>.log` in any environment the engine was mounted in; both cable
+  channels checked only the (nil by default) authentication hook, so anything
+  reaching the host's `/cable` could subscribe and start a log tail or write
+  state. Running the host's auth proc now happens after the environment check,
+  so a disallowed environment 404s without it.
+- **`model_schema` validates its parameter.** The model name flowed into a file
+  path without a format check, so `..` segments escaped the workspace.
+- **Git ref patterns reject a leading dash**, and `git show` takes
+  `--end-of-options` — a ref beginning with `-` was argument injection into a
+  documented git option.
+
+### Performance
+- **Typing no longer re-renders the whole application.** Every keystroke wrote
+  the full document into the store, which re-rendered an app subscribed to all
+  of it. Content writes are now throttled (250 ms, trailing) with a documented
+  flush-on-save contract, and the dirty flag is written only on a clean/dirty
+  transition. On top of that: the file tree is no longer deep-copied per render,
+  the model-graph scene (~10k SVG elements) no longer rebuilds when unrelated
+  state moves, and blame/test view zones, the tab strip's smooth scroll, and the
+  problem counts no longer churn per keypress.
+- **Monaco's ruby-lsp providers honour cancellation.** `documentHighlight`
+  fires per cursor move and was POSTing the entire buffer with no way to cancel
+  it, so superseded requests stayed in flight; all eight raw providers now
+  thread Monaco's `CancellationToken` through one shared path, and highlights
+  memoise per word occurrence.
+- **ruby-lsp requests pipeline again.** The document mutex was held across the
+  whole request/response round-trip, so a single diagnostics call (10 s budget)
+  or rename (30 s) blocked every hover and highlight in the process. It is now
+  held only across the write, which is what actually needs ordering. Abandoned
+  requests send `$/cancelRequest` rather than leaving a single-threaded server
+  computing a result nobody will read.
+- **Conditional GETs on the polled and static routes.** Monaco's 14 MB of
+  assets carried no validators and were re-fetched on every page load; `/files`
+  shipped roughly 1 MB of JSON on a 10 s poll and now answers 304 from a digest
+  memoised with the existing tree cache. `/git_status`, hit every 5 s, is TTL
+  cached instead of spawning two git subprocesses per poll.
+- **`find_branch_base` costs 2 git spawns instead of up to 12**, resolving the
+  candidate list with one `for-each-ref`. Commit detail drops from 3 spawns to
+  2, and the line-diff probe only asks whether a file is untracked when the
+  diff came back empty.
+- **A JS save no longer rebuilds the whole workspace JS program behind a global
+  lock**, and a `.rb` save no longer invalidates the JS program and globals
+  caches at all. Go-to-definition no longer rewrites the entire on-disk cache
+  (tens of MB of JSON) on any lookup that parsed something new.
+- Smaller: one `lstat` per tree entry instead of three stats, unbounded
+  subprocess output capped, and the exclusion matcher splits each path once
+  rather than once per pattern.
+
+### Fixed
+- **Pending migrations no longer lock the editor.** `CheckPending` is swapped
+  for a wrapper that runs the identical check for host traffic but records
+  rather than raises for the editor's, so the tree, opening a file and saving
+  one keep working — including saving the migration causing it. The warning
+  rides a response header, so it appears for a migration created mid-session
+  and clears once migrated without a reload. Host traffic is still blocked
+  exactly as Rails intends. The fallback shell also requested its Sprockets
+  assets under the engine mount, where they 404, and hardcoded `/mbeditor`
+  instead of the configured mount path.
+- **Saves no longer degrade under a burst.** A timeout was counted as an
+  unreachable server, which suppressed the polls that would have proven it up;
+  `files_changed` is coalesced once at the WebSocket dispatch (15 writes: 15
+  dispatches to 1); panes re-ran `git diff` on every save anywhere in the
+  workspace; and the lite git poll escalated to the full fan-out twice per save
+  (12 saves: 12 fan-outs to 1).
+- **Replace All left open tabs showing pre-replace text.** The refresh treated
+  a model-registry entry as a Monaco model, so the update silently no-opped
+  into a bare `catch` — and saving that tab afterwards wrote the stale content
+  back over the replacement.
+- **A dropped cable connection disconnected the host application's own
+  ActionCable consumer** when the host provided one, taking its channels down
+  with it, and left collaboration rooms bound to the dead consumer with no
+  indication they were dead. Consumers are disconnected only when mbeditor
+  created them, and rooms rejoin on reconnect.
+- **ruby-lsp failed entirely for any workspace path containing a space** or
+  other character needing escaping: the `file://` URI was built by
+  interpolation, so ruby-lsp's own `URI` parse raised and every request fell
+  back silently. Return-path comparisons unescape before matching the
+  workspace root.
+- **Git status mangled paths with spaces, non-ASCII characters, or renames.**
+  Porcelain output was read verbatim, so quoted and octal-escaped paths arrived
+  unopenable and missed their numstat enrichment; both sides now use `-z`.
+- **Saves and editor state are written atomically.** Both truncated in place,
+  so a reader landing mid-write parsed an empty file and silently reported no
+  open tabs, and a crash mid-write left the file empty for good. Writes go to a
+  temporary file and rename, resolving through symlinks so a linked file stays
+  a link.
+- **Literal (non-regex) replace corrupted replacements containing
+  backslashes** — `\1`, `\&` and `\\` were interpreted as backreferences across
+  up to 500 files.
+- **A user-supplied search regex could pin a worker indefinitely.** Patterns
+  are compiled with `Regexp.timeout` where the Ruby version supports it;
+  `Timeout.timeout` cannot interrupt a regex match, which is what the previous
+  guard relied on.
+- **A failed ruby-lsp handshake orphaned the child process**, leaving it
+  indexing and holding memory, and up to three could accumulate.
+- **Branch switches left stale buffers and diagnostics.** A checkout rewrites
+  the working tree and nothing told the editor; the git poll now announces it,
+  the app re-reads the tree and every open tab (dirty ones still prompt rather
+  than being clobbered), and `/files?refresh=1` bypasses the 15 s tree cache.
+- **The Problems panel filled with vendored gem source** when a host
+  `.rubocop.yml` replaced RuboCop's default excludes, and reported TypeScript's
+  implicit-any advice on plain JS/JSX, where there are no annotations to add.
+- **`HistoryService` rejected an empty base**, so the first history entry for a
+  file 400'd.
+- Also: a V8 isolate leak in the JS syntax checker, unbounded growth in the
+  collaboration delta log and several per-path caches, JS member completions
+  cached with a stale insert range, `quick_fix`/format/haml-lint running with
+  no timeout, a negative log offset returning a 500, and configured JS globals
+  being dropped when the symbol cap was reached.
+
+### Tests
+- The pending-migration middleware tests built `ActiveRecord::PendingMigrationError`
+  with no arguments, whose initializer lists the pending migrations and so needs
+  a database connection; every CI runner without one failed all six.
+- Two stubs restored `AvailabilityProbe.rg` by rebinding a captured `Method`,
+  which raises `can't bind singleton method to a different class` if the class
+  is reloaded in between — leaving `rg` undefined and failing every later search
+  and workspace test in that process. They alias instead.
+
+## [0.12.9] - 2026-08-07
+
+### Added
+- **Problems panel severity filter.** Three toggle chips — errors, warnings,
+  info — each showing its live count, filtering the list independently of the
+  text filter. Multi-select rather than one-of-three, so "errors and warnings
+  but not the convention noise" is expressible. The selection persists, and the
+  last active severity stays latched on so the panel can't be filtered down to
+  an unexplained blank.
+- **Search results carry match columns.** Clicking a result now puts the cursor
+  at the end of the matched text instead of the start of the line, ready to
+  type. Columns are measured against the raw source line on the server —
+  the row's display text is stripped, so a column derived from it would land
+  short by the indent on every indented hit.
+
+### Changed
+- **The Problems header no longer restates its counts in prose.** The severity
+  chips carry the same three numbers.
+- **Paste re-indents instead of reformatting.** Pasting ran the pasted range
+  through Prettier, which reprinted the whole enclosing statement — and for a
+  paste that filled the document, every line of it — so pasting a snippet
+  rewrote code you never touched. Paste now only re-indents to the file's
+  indentation setting; quotes, semicolons and spacing come through exactly as
+  copied. The setting is renamed "Format on paste" → "Indent on paste"
+  (`indentOnPaste`, still on by default). Monaco ships no indentation rules for
+  JavaScript, which would have made the re-indent a silent no-op there, so
+  VS Code's JS rules are now registered. Format-on-save is unchanged and still
+  off by default.
+
+### Fixed
+- **Go-to-definition on a JS symbol defined in the same file opened a junk tab
+  named after a number.** Models are created without an explicit URI, so Monaco
+  identifies each as `inmemory://model/N`; the TS worker returns that URI for
+  an in-file definition, and the editor opener stripped it to a path and opened
+  a phantom tab called "57". Only `file://` resources are treated as workspace
+  files now — the rest go back to Monaco, which reveals the position in the
+  current editor.
+- **Clicking a search result sometimes landed on the wrong line.** Opening a
+  hit in a file that wasn't already open ran the jump against a still-empty
+  model: it clamped to line 1 and then cleared the pending jump, so when the
+  content finally arrived nothing re-triggered it. Whether it misbehaved came
+  down to whether the fetch beat a 50 ms timer — hence "sometimes". The jump
+  now waits for the content, cancels a superseded timer, and clamps to the
+  file's real length when a result outlives the line it pointed at.
+- **Search results ignored created and deleted files.** Only saves dropped the
+  client-side search cache, so a search re-run after adding or removing a file
+  was served the stale cached page. Every structural mutation now invalidates
+  it and re-runs the active query.
+- **Search and the git status counts lagged behind file changes.** The
+  live-result refresh sat behind a 2 s debounce (now 250 ms), and every save
+  fired the full `/git_info` fan-out — the most expensive request the editor
+  makes — twice over, once directly and once from the broadcast handler, which
+  on a dev server with a few threads queued the tree and search requests behind
+  it. Saves and file mutations now use the cheap `/git_status` probe, which
+  patches the branch and file list immediately and escalates to the fan-out
+  itself only when the branch actually changed.
+
 ## [0.12.8] - 2026-08-07
 
 ### Added

data/app/assets/javascripts/mbeditor/application.js

@@ -27,12 +27,18 @@
 //= require mbeditor/components/TestResultsPanel
 //= require mbeditor/components/LogPanel
 //= require mbeditor/components/ProblemsPanel
+//= require mbeditor/components/TestRunPanel
 //= require mbeditor/components/CodeReviewPanel
 //= require mbeditor/components/EditorPanel
 //= require mbeditor/components/FileTree
 //= require mbeditor/components/GitPanel
 //= require mbeditor/components/QuickOpenDialog
 //= require mbeditor/components/TabBar
+// Both import modals must be required *inside* the IIFE: React is an IIFE
+// parameter (window.React is deliberately never set), so a component file
+// placed after the tail resolves a bare `React` to undefined and takes the
+// whole app down the first time it renders.
+//= require mbeditor/components/ImportConflictModal
+//= require mbeditor/components/ImportDialog
 //= require mbeditor/components/MbeditorApp
 //= require mbeditor/application_iife_tail
-//= require mbeditor/components/ImportConflictModal

data/app/assets/javascripts/mbeditor/collaboration_service.js

@@ -295,6 +295,29 @@ var CollaborationService = (function () {
     }
   }
 
+  // Re-open every room's channel subscription on the current consumer.
+  //
+  // A cable drop tears the consumer down and takes every CollaborationChannel
+  // subscription with it — silently, because isAvailable() reports cable
+  // *support*, not liveness. Nothing here noticed: the rooms stayed in _rooms
+  // with dead subscriptions, so edits stopped reaching peers until the file was
+  // closed and reopened. WebSocketService calls this when the EditorChannel
+  // reconnects. Only the wire is replaced; the Yjs doc, the binding and the undo
+  // history all survive, and the re-sent sync snapshot re-applies harmlessly
+  // (Y.applyUpdate is idempotent).
+  function rejoinRooms() {
+    Object.keys(_rooms).forEach(function (path) {
+      var room = _rooms[path];
+      try { if (room.subscription) room.subscription.unsubscribe(); } catch (e) { /* already dead */ }
+      room.subscription = WebSocketService.subscribeCollaboration(path, {
+        // Awareness is never server-persisted, so peers lost our caret with the
+        // connection and would not see it again until we happened to move.
+        connected: function () { _sendLocalAwareness(room); },
+        received: function (data) { _onMessage(room, data); }
+      });
+    });
+  }
+
   // Register the current editor/model for a room and request a binding. Called on
   // every editor (re)creation (tab switch recreates the editor; the model and the
   // Yjs doc persist). opts.onSeeded is invoked once the binding has set the model,
@@ -561,6 +584,7 @@ var CollaborationService = (function () {
   // Client IDs are globally unique, so one shared <style> element covers all open
   // files. Re-runs on any awareness change (cheap; small participant counts).
   var _styleEl = null;
+  var _cursorCss = null;
   function _renderCursorStyles() {
     if (typeof document === 'undefined') return;
     if (!_styleEl) {
@@ -593,6 +617,12 @@ var CollaborationService = (function () {
             'font-family:sans-serif;z-index:10;pointer-events:none;}';
       });
     });
+    // Awareness changes on every caret move and every scroll frame, but the
+    // styles only depend on who is here and what colour they chose — which
+    // almost never changes. Re-assigning textContent invalidates the document's
+    // style rules, so skip the write when the CSS is identical.
+    if (css === _cursorCss) return;
+    _cursorCss = css;
     _styleEl.textContent = css;
   }
 
@@ -739,6 +769,7 @@ var CollaborationService = (function () {
     onAvailabilityChange: onAvailabilityChange,
     isEnabledFor: isEnabledFor,
     ensureRoom: ensureRoom,
+    rejoinRooms: rejoinRooms,
     bindEditor: bindEditor,
     unbindEditor: unbindEditor,
     leaveRoom: leaveRoom,

data/app/assets/javascripts/mbeditor/color_provider.js

@@ -87,6 +87,11 @@
   function provideDocumentColors(model) {
     var colors = [];
     var lineCount = model.getLineCount();
+    // Registered for every language and re-run on every change, so a big file
+    // pays two regex passes per line for every keystroke. Same threshold
+    // EditorPanel's applyLargeFileTuning uses to switch off the other
+    // whole-document decorations.
+    if (lineCount > 2500) return [];
     for (var ln = 1; ln <= lineCount; ln++) {
       var line = model.getLineContent(ln);
       if (line.length > 2000) continue; // skip pathological lines

data/app/assets/javascripts/mbeditor/components/CollapsibleSection.js

@@ -49,7 +49,9 @@ var CollapsibleSection = function CollapsibleSection(_ref) {
       icon && React.createElement("i", { className: "collapsible-icon " + icon }),
       React.createElement(
         "span",
-        { className: "collapsible-title" },
+        // The title truncates away entirely on a narrow sidebar, so it carries
+        // its own tooltip — otherwise the section becomes unidentifiable.
+        { className: "collapsible-title", title: typeof title === 'string' ? title : undefined },
         title
       ),
       actions && React.createElement(

data/app/assets/javascripts/mbeditor/components/EditorPanel.js

@@ -6,6 +6,7 @@ var _React = React;
 var useState = _React.useState;
 var useEffect = _React.useEffect;
 var useRef = _React.useRef;
+var useMemo = _React.useMemo;
 
 var IMAGE_EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'svg', 'ico', 'webp', 'bmp', 'avif'];
 
@@ -611,7 +612,7 @@ var EditorPanel = function EditorPanel(_ref) {
       var _histBranch = EditorStore.getState().gitBranch || '';
       if (_histBranch) {
         if (_reusingModel) {
-          HistoryService.resumeTracking(_histBranch, tab.path);
+          HistoryService.resumeTracking(_histBranch, tab.path, modelObj.getValue());
         } else {
           HistoryService.beginTracking(_histBranch, tab.path, tab.content || '');
         }
@@ -647,9 +648,8 @@ var EditorPanel = function EditorPanel(_ref) {
       autoClosingBrackets: editorPrefs.autoClosingBrackets || 'always',
       autoClosingQuotes: editorPrefs.autoClosingQuotes || 'always',
       autoIndent: editorPrefs.autoIndent || 'full',
-      // Monaco's own format-on-paste is left off: it never ran the formatter
-      // here. attachEditorFeatures drives it from onDidPaste instead, gated on
-      // the same editorPrefs.formatOnPaste setting.
+      // Paste inserts what was copied, unchanged. See attachEditorFeatures for
+      // why re-indenting it was removed rather than repaired.
       formatOnPaste: false,
       formatOnType: editorPrefs.formatOnType === true, // off by default: on-type formatting adds per-keystroke latency on slow machines
       quickSuggestions: editorPrefs.quickSuggestions !== false,
@@ -1213,10 +1213,9 @@ var EditorPanel = function EditorPanel(_ref) {
         autoClosingBrackets: editorPrefs.autoClosingBrackets || 'always',
         autoClosingQuotes: editorPrefs.autoClosingQuotes || 'always',
         autoIndent: editorPrefs.autoIndent || 'full',
-        // Monaco's own format-on-paste is left off: it never ran the formatter
-      // here. attachEditorFeatures drives it from onDidPaste instead, gated on
-      // the same editorPrefs.formatOnPaste setting.
-      formatOnPaste: false,
+        // Paste inserts what was copied, unchanged. See attachEditorFeatures
+        // for why re-indenting it was removed rather than repaired.
+        formatOnPaste: false,
         formatOnType: editorPrefs.formatOnType === true, // off by default: on-type formatting adds per-keystroke latency on slow machines
         quickSuggestions: editorPrefs.quickSuggestions !== false,
         wordBasedSuggestions: editorPrefs.wordBasedSuggestions || 'currentDocument',
@@ -1301,22 +1300,40 @@ var EditorPanel = function EditorPanel(_ref) {
     return function() { window.removeEventListener('mbeditor:focusPane', onFocusPane); };
   }, [paneId]);
 
-  // Jump to line if specified
+  // Jump to line if specified.
+  //
+  // The wait for content is load-bearing, not defensive. Opening a search hit
+  // in a file that wasn't already open runs this effect once while the model
+  // is still empty: the jump clamped to line 1 and then cleared gotoLine, so
+  // when the content finally arrived there was nothing left to re-trigger it
+  // and the cursor stayed on the wrong line. Whether it misbehaved came down
+  // to whether the fetch beat a 50 ms timer — hence "sometimes".
   useEffect(function () {
-    if (tab.gotoLine && monacoRef.current) {
-      (function () {
-        var editor = monacoRef.current;
-        setTimeout(function () {
-          editor.revealLineInCenter(tab.gotoLine);
-          editor.setPosition({ lineNumber: tab.gotoLine, column: tab.gotoCol || 1 });
-          editor.focus();
-
-          TabManager.saveTabViewState(tab.id, editor.saveViewState());
-          TabManager.clearGotoLine(paneId, tab.path);
-        }, 50);
-      })();
-    }
-  }, [tab.gotoLine, tab.content]); // need tab.content in dep array so if it loads asynchronously, the jump happens AFTER content loads
+    if (!tab.gotoLine || !monacoRef.current) return;
+    if (tab.loading) return;
+
+    var editor = monacoRef.current;
+    var timer = setTimeout(function () {
+      var model = editor.getModel();
+      if (!model || model.isDisposed()) return;
+
+      // A result can outlive the line it pointed at (the file shrank since the
+      // scan). Clamp instead of asking Monaco for a line that isn't there.
+      var line = Math.max(1, Math.min(tab.gotoLine, model.getLineCount()));
+      var column = tab.gotoCol || 1;
+      var maxColumn = model.getLineMaxColumn(line);
+      if (column > maxColumn) column = maxColumn;
+
+      editor.revealLineInCenter(line);
+      editor.setPosition({ lineNumber: line, column: column });
+      editor.focus();
+
+      TabManager.saveTabViewState(tab.id, editor.saveViewState());
+      TabManager.clearGotoLine(paneId, tab.path);
+    }, 50);
+
+    return function () { clearTimeout(timer); };
+  }, [tab.gotoLine, tab.gotoCol, tab.content, tab.loading]);
 
   // Apply RuboCop markers
   useEffect(function () {
@@ -1477,8 +1494,19 @@ var EditorPanel = function EditorPanel(_ref) {
     gitLineRefreshRef.current = refresh;
 
     // Immediate path for writes mbeditor made itself.
+    //
+    // Only when *this* file is one of the ones that changed: saving some other
+    // file cannot move this file's diff against HEAD. Refreshing regardless
+    // meant every open pane ran a git diff on every save anywhere in the
+    // workspace, so the cost of a save scaled with how many editors were open.
+    // A broadcast that names no paths still refreshes — that is the "something
+    // happened, re-check everything" case (a commit, a branch switch), which
+    // genuinely can change this file's diff without touching it.
     var hasSocket = typeof WebSocketService !== 'undefined' && WebSocketService.onFilesChanged;
-    var onChanged = hasSocket ? function () { refresh(); } : null;
+    var onChanged = hasSocket ? function (payload) {
+      if (payload && payload.paths && payload.paths.indexOf(tab.path) === -1) return;
+      refresh();
+    } : null;
     if (onChanged) WebSocketService.onFilesChanged(onChanged);
 
     return function () {
@@ -1554,6 +1582,16 @@ var EditorPanel = function EditorPanel(_ref) {
   //
   // Decorations, not view zones: a hint belongs on the line, and a zone would
   // push the code around every time a file was opened.
+  //
+  // Redrawn whenever the text changes, not only when the file is opened. A
+  // decoration is a zero-width range pinned at the end of the `def` line, and
+  // Monaco keeps that position through an edit rather than re-deriving it — so
+  // replacing a method (a paste over the selection is the usual way) left the
+  // hint at a column that now falls in the middle of whatever text took its
+  // place, rendering as `def sho  GET /orders/:idw`. Nothing recomputed it,
+  // so saving did not clear it either; it survived until the file was
+  // reopened. The route data itself only depends on the route set, so an edit
+  // redraws from the cached response without asking the server again.
   useEffect(function () {
     var editor = monacoRef.current;
     if (!editor || !window.monaco) return;
@@ -1563,17 +1601,19 @@ var EditorPanel = function EditorPanel(_ref) {
       routeDecorationsRef.current = editor.deltaDecorations(routeDecorationsRef.current, []);
     };
 
-    if (!tab.path || !/^app\/controllers\/.+_controller\.rb$/.test(tab.path)) {
+    if (editorPrefs.routeHints === false ||
+        !tab.path || !/^app\/controllers\/.+_controller\.rb$/.test(tab.path)) {
       clear();
       return;
     }
 
     var cancelled = false;
-    FileService.getRoutes(tab.path).then(function (data) {
+    var redrawTimer = null;
+
+    var draw = function (actions) {
       if (cancelled) return;
-      var actions = (data && data.actions) || {};
       var model = editor.getModel();
-      if (!model) return;
+      if (!model || model.isDisposed()) return;
 
       var decorations = [];
       var text = model.getValue().split('\n');
@@ -1616,10 +1656,47 @@ var EditorPanel = function EditorPanel(_ref) {
       });
 
       routeDecorationsRef.current = editor.deltaDecorations(routeDecorationsRef.current, decorations);
+    };
+
+    var contentSub = null;
+    FileService.getRoutes(tab.path).then(function (data) {
+      if (cancelled) return;
+      var actions = (data && data.actions) || {};
+      draw(actions);
+
+      // Debounced: a redraw per keystroke would rebuild every decoration in
+      // the file for an edit that usually cannot have moved one.
+      var model = editor.getModel();
+      if (!model || !model.onDidChangeContent) return;
+      contentSub = model.onDidChangeContent(function () {
+        clearTimeout(redrawTimer);
+        redrawTimer = setTimeout(function () { draw(actions); }, 250);
+      });
     }).catch(function () { /* hints are additive; a failure just means none */ });
 
-    return function () { cancelled = true; clear(); };
-  }, [tab.path, tab.externalContentVersion, monacoReady]);
+    return function () {
+      cancelled = true;
+      clearTimeout(redrawTimer);
+      if (contentSub) contentSub.dispose();
+      clear();
+    };
+  }, [tab.path, tab.externalContentVersion, monacoReady, editorPrefs.routeHints]);
+
+  // Blame and test view zones are anchored to line numbers, so they only need
+  // rebuilding once an edit has settled. Both effects used to list tab.content
+  // directly, which tore down and re-created every zone in the file on every
+  // keystroke. This ticks 250 ms after the last change instead — the same
+  // treatment the route-hint redraw above already gets.
+  var _useStateZT = useState(0);
+  var _useStateZT2 = _slicedToArray(_useStateZT, 2);
+  var zoneTick = _useStateZT2[0];
+  var setZoneTick = _useStateZT2[1];
+  useEffect(function () {
+    var timer = setTimeout(function () {
+      setZoneTick(function (n) { return n + 1; });
+    }, 250);
+    return function () { clearTimeout(timer); };
+  }, [tab.content]);
 
   // Render Blame block headers (author + summary) above contiguous commit regions.
   useEffect(function () {
@@ -1707,8 +1784,8 @@ var EditorPanel = function EditorPanel(_ref) {
       blameDecorationsRef.current = editor.deltaDecorations(blameDecorationsRef.current, []);
     }
 
-  // Include tab.content so blame re-renders once async file contents finish loading.
-  }, [blameData, isBlameVisible, tab.id, tab.content]);
+  // zoneTick, not tab.content: the zones follow the content, 250 ms behind it.
+  }, [blameData, isBlameVisible, tab.id, zoneTick]);
 
   // Check whether the current tab is the source file for the test that was run.
   // e.g. testPanelFile = "test/controllers/theme_controller_test.rb"
@@ -1786,6 +1863,14 @@ var EditorPanel = function EditorPanel(_ref) {
     return null;
   };
 
+  // treeHasPath walks the whole file tree once per candidate, and the Test
+  // button asked for this on every render — so once per keystroke. treeData is
+  // deliberately outside the React.memo comparator below, so it can only change
+  // on a render this component was going to do anyway.
+  var testFileForTab = useMemo(function () {
+    return matchingTestFilePath(tab.path);
+  }, [tab.path, treeData]);
+
   // Map a test method name to the best-matching line in the source file.
   // Extracts keywords from the test name and scores each source line.
   var mapTestToSourceLine = function(testName, sourceContent) {
@@ -1822,9 +1907,17 @@ var EditorPanel = function EditorPanel(_ref) {
     var model = editor.getModel();
     var lineCount = model ? model.getLineCount() : 0;
 
-    var showHere = testPanelFile && tab.path && isSourceForTest(tab.path, testPanelFile);
+    // Which test file a result entry belongs to. A whole-suite run spans many
+    // of them and stamps each entry with its own `file`, so there is no single
+    // testPanelFile to gate on; a per-file run leaves `file` unset on the
+    // passing entries and testPanelFile is the answer for those.
+    var testFileFor = function (t) { return (t && t.file) || testPanelFile; };
+    var relevantTests = ((testResult && testResult.tests) || []).filter(function (t) {
+      var file = testFileFor(t);
+      return file && tab.path && isSourceForTest(tab.path, file);
+    });
 
-    if (!testResult || !testInlineVisible || !showHere) {
+    if (!testResult || !testInlineVisible || relevantTests.length === 0) {
       clearTestZones(editor);
       testDecorationIdsRef.current = editor.deltaDecorations(testDecorationIdsRef.current, []);
       return;
@@ -1835,10 +1928,8 @@ var EditorPanel = function EditorPanel(_ref) {
       testDecorationIdsRef.current = editor.deltaDecorations(testDecorationIdsRef.current, []);
 
       var normPath = function(p) { return p ? p.replace(/^\/+/, '') : ''; };
-      var viewingTestFile = normPath(tab.path) === normPath(testPanelFile);
 
-      var tests = testResult.tests || [];
-      var testsWithStatus = tests.filter(function (t) {
+      var testsWithStatus = relevantTests.filter(function (t) {
         return t.status === 'pass' || t.status === 'fail' || t.status === 'error';
       });
 
@@ -1847,6 +1938,9 @@ var EditorPanel = function EditorPanel(_ref) {
       // Determine line number for each test
       var sourceContent = tab.content || '';
       var mapped = testsWithStatus.map(function(t) {
+        // Per entry, not per panel: in a suite run this tab is the test file
+        // for some entries and the source counterpart for others.
+        var viewingTestFile = normPath(tab.path) === normPath(testFileFor(t));
         var line;
         if (viewingTestFile && t.line && t.line >= 1 && t.line <= lineCount) {
           line = t.line;
@@ -1905,8 +1999,9 @@ var EditorPanel = function EditorPanel(_ref) {
       testDecorationIdsRef.current = editor.deltaDecorations(testDecorationIdsRef.current, []);
     }
 
-  // Include tab.content so zones re-render once async file content loads (same as blame).
-  }, [testResult, testInlineVisible, testPanelFile, tab.id, tab.path, tab.content]);
+  // zoneTick, not tab.content — see the blame effect. The effect still reads
+  // tab.content for mapTestToSourceLine; the tick only decides when it re-runs.
+  }, [testResult, testInlineVisible, testPanelFile, tab.id, tab.path, zoneTick]);
 
   var sourceTab = tab.isPreview ? findTabByPath(tab.previewFor) : null;
   var markdownContent = tab.isPreview ? sourceTab && sourceTab.content || tab.content || '' : tab.content || '';
@@ -2235,7 +2330,7 @@ var EditorPanel = function EditorPanel(_ref) {
         React.createElement('i', { className: 'fas fa-shoe-prints', style: { marginRight: editorPrefs.toolbarIconOnly ? 0 : '5px', flexShrink: 0 } }),
         !editorPrefs.toolbarIconOnly && React.createElement('span', { className: 'ide-toolbar-label' }, isBlameLoading ? 'Loading...' : 'Blame')
       ),
-      testAvailable && matchingTestFilePath(tab.path) && React.createElement(
+      testAvailable && testFileForTab && React.createElement(
         'button',
         {
           className: 'ide-icon-btn',

data/app/assets/javascripts/mbeditor/components/FileTree.js

@@ -423,7 +423,12 @@ var FileTree = function FileTree(_ref) {
     return result;
   };
 
-  var flatItems = flattenVisible(items || [], 0, '');
+  // A per-level localeCompare sort of the whole visible tree, re-run on every
+  // render — including the ones caused by a git poll or a tab switch, neither
+  // of which can change the shape of the tree. Only these three inputs can.
+  var flatItems = useMemo(function () {
+    return flattenVisible(items || [], 0, '');
+  }, [items, expandedDirs, pendingCreate]);
   flatItemsRef.current = flatItems;
 
   var totalHeight = flatItems.length * ROW_HEIGHT;