mbeditor 0.12.5 → 0.12.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 021b4117178c3c82c72bd21709de8665d578557f5833b3b1b525e25ef672ce10
-  data.tar.gz: efc3c48d714d8973b1df5614c05647e21a11856ada4591b3af4b58261e248332
+  metadata.gz: dffea86be286ee0bdcb216589b12264dcac613a33e59aa2828490706785e1825
+  data.tar.gz: f786fe449deccc7ff1971c8df15015b7ee0507b45b14a332f83e162b44facc01
 SHA512:
-  metadata.gz: 2655b76c9b8f77dfd7c2127124eae19d9536de389e532f0da51a954adf0e5079042e72175c76a14d047788b13fa7a85193d23353f1112e75d602cc62dde3bc4b
-  data.tar.gz: a4332fc2c00d5caf96c8f26d774892e7adf23f42b09782555cb359c60d601dc419e6b7abab44ae589f12e8804b5d43e9ce1303d9858227eb55ca3e5cb5b32f8f
+  metadata.gz: b1cf4fcf24d9868b1b5a284c1de2f8eb3b5032a10d8cb3a9ebb1677eed3a6ce9660e658a43f80652ec1a3edb5195aadcf01fc428fc381ed5f62618d59dde4286
+  data.tar.gz: 3c0c8dc6d5d2aee702d0ed1af2814e884cd204702383dafc21871ffcf2a0b8fa8e871a971d69824ea44f7831f335d3f7e8d0999c832142e5b510d43033ad10cd

data/CHANGELOG.md

@@ -7,6 +7,75 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.6] - 2026-08-05
+
+### Added
+- **Format All.** A second toolbar button formats every open document. Each tab
+  is formatted independently and failures are collected rather than thrown, so
+  one unparseable file cannot stop the rest; the status line reports how many
+  were formatted, skipped and failed.
+- **Format on paste actually formats.** `formatOnPaste` has been on by default
+  for a long time and did nothing outside Ruby: Monaco acts on a paste only
+  through a *range* formatting provider, and none was registered. Prettier-backed
+  range and document providers now cover JS/JSX, JSON, CSS/SCSS/LESS, HTML and
+  Markdown. A paste that fills the document is formatted as a document — so
+  pasting into a blank file formats the whole thing — while a paste in the middle
+  is formatted as a range, reprinting the smallest enclosing statement and
+  leaving the rest of the file byte-identical. Code copied in from a spaces
+  project therefore lands as tabs (or the reverse), which was previously a manual
+  chore that never converted cleanly.
+- **Files symlinked in from outside the workspace now open.** An app that links a
+  shared config directory or a sibling engine into its tree could see those files
+  in the explorer but not open them — the tab opened and closed itself a moment
+  later. Symlinks are now followed the way a file manager does. Containment is
+  still enforced: `File.expand_path` collapses `..` before a lexical check
+  against the workspace root, so no request can name anything outside it, and
+  git operations stay strictly inside the repo.
+
+### Fixed
+- **Search returned nothing, instantly, on some workspaces without ripgrep.** The
+  git-grep tier was chosen on the mere presence of a `.git` entry, with no check
+  that git could actually open the repo. When it cannot — dubious ownership under
+  Docker, a `.git` file pointing at a gitdir that moved, no git binary on the
+  server's `PATH` — `git grep` fails, its stderr goes to `/dev/null`, and the
+  result is an empty set indistinguishable from "no matches". The tier is now
+  gated on `git rev-parse --is-inside-work-tree`, which fails in exactly those
+  cases, so a bad repo falls through to plain grep. Definition lookups had the
+  same check and were silently broken the same way.
+- **Formatting ignored the tab/space setting.** There were four copies of the
+  Prettier options and they had drifted: two read a `prettierTabWidth` /
+  `prettierUseTabs` pair that no settings screen ever wrote, frozen at two
+  spaces, overriding the `tabSize` / `insertSpaces` actually configured. A JSX
+  file in a tabs workspace came back space-indented. Indentation now comes from
+  the same preferences Monaco itself is given.
+- **One JS file had two formatters that disagreed.** Monaco's TypeScript worker
+  registers its own range formatter for `javascript` and Monaco uses whichever it
+  finds first, so the toolbar button went through Prettier while `Shift+Alt+F`
+  and format-on-paste got the worker's two-space, no-semicolon output. The
+  worker's formatting is switched off; its completions, hovers, diagnostics and
+  rename are untouched.
+- **"Server offline" flashed during ordinary actions.** The reachability check
+  counted any error without a response as a network failure, and a request the
+  editor aborts itself has none either. The editor cancels constantly — each
+  keystroke supersedes the previous search, hover and completion providers abort
+  when the cursor moves on, opening a file aborts its own prefetch — so two in a
+  row declared the server offline until the `/ping` probe a second later put it
+  back. Creating a file reliably triggered it. Cancellations are now ignored; a
+  genuinely unreachable host still marks offline and still recovers.
+- **Warnings logged by the host app from mbeditor's own hooks were swallowed.**
+  Editor requests were silenced at `ERROR`, which hides Rails' own INFO-level
+  request lines but also everything a host app logs from inside
+  `authenticate_with` or `user_name_callback` — those procs run within the
+  request, so a developer debugging their own hook saw nothing and had no way to
+  know why. Silenced at `WARN` now, which still hides the request lines.
+
+### Changed
+- RuboCop's output is taken as-is. Ruby indentation belongs to the project's
+  `.rubocop.yml`, so rewriting it in the editor fought the linter about to run
+  over the same file. The previous code converted the source to tabs *before*
+  handing it to RuboCop, which discarded it. To convert an already-open file,
+  use Monaco's built-in "Convert Indentation to Tabs / to Spaces" (F1).
+
 ## [0.12.5] - 2026-08-03
 
 ### Fixed

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

@@ -643,7 +643,10 @@ var EditorPanel = function EditorPanel(_ref) {
       autoClosingBrackets: editorPrefs.autoClosingBrackets || 'always',
       autoClosingQuotes: editorPrefs.autoClosingQuotes || 'always',
       autoIndent: editorPrefs.autoIndent || 'full',
-      formatOnPaste: editorPrefs.formatOnPaste !== false,
+      // 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,
       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',
@@ -1206,7 +1209,10 @@ var EditorPanel = function EditorPanel(_ref) {
         autoClosingBrackets: editorPrefs.autoClosingBrackets || 'always',
         autoClosingQuotes: editorPrefs.autoClosingQuotes || 'always',
         autoIndent: editorPrefs.autoIndent || 'full',
-        formatOnPaste: editorPrefs.formatOnPaste !== false,
+        // 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,
         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',

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

@@ -39,7 +39,52 @@ var GIT_PANEL_MIN_WIDTH = 280;
 var PANE_MIN_WIDTH_PERCENT = 20;
 var PANE_MAX_WIDTH_PERCENT = 80;
 var SIDEBAR_COLLAPSED_WIDTH = 48;
-var SUPPORTED_PRETTIER_EXTS = ['js', 'jsx', 'json', 'css', 'scss', 'html', 'md'];
+// Extension -> Prettier parser. Limited to what the vendored plugins actually
+// parse (babel, estree, html, postcss, markdown); anything outside this map
+// falls through to Monaco's re-indent.
+//
+// One map, one options builder, one runner — there were four copies of each,
+// and they had drifted: two read a `prettierTabWidth`/`prettierUseTabs` pair
+// that no settings screen ever wrote, so Prettier reprinted every JS/JSX file
+// at two spaces however the editor was configured.
+var PRETTIER_PARSERS = {
+  js: 'babel', jsx: 'babel', mjs: 'babel', cjs: 'babel',
+  json: 'json', jsonc: 'json', json5: 'json5',
+  css: 'css', scss: 'scss', less: 'less',
+  html: 'html', vue: 'vue',
+  md: 'markdown', markdown: 'markdown'
+};
+var SUPPORTED_PRETTIER_EXTS = Object.keys(PRETTIER_PARSERS);
+
+function prettierParserFor(path) {
+  return PRETTIER_PARSERS[String(path || '').split('.').pop().toLowerCase()] || null;
+}
+
+// Indentation comes from the editor's own tabSize/insertSpaces, so formatting
+// produces what the user set up. `insertSpaces !== true` mirrors how
+// EditorPanel configures Monaco: anything but an explicit true means tabs.
+function prettierOptions(prefs, parserName, extra) {
+  return Object.assign({
+    parser: parserName,
+    plugins: Object.values(window.prettierPlugins || {}),
+    printWidth: prefs.prettierPrintWidth != null ? prefs.prettierPrintWidth : 80,
+    tabWidth: prefs.tabSize != null ? prefs.tabSize : 4,
+    useTabs: prefs.insertSpaces !== true,
+    semi: prefs.prettierSemi !== false,
+    singleQuote: !!prefs.prettierSingleQuote,
+    trailingComma: prefs.prettierTrailingComma || 'all',
+    bracketSpacing: prefs.prettierBracketSpacing !== false
+  }, extra || {});
+}
+
+// Format with Prettier, loading it on first use. Rejects if it cannot be
+// loaded, so callers can report that rather than appear to do nothing.
+function runPrettier(source, prefs, parserName, extra) {
+  var go = function () { return window.prettier.format(source, prettierOptions(prefs, parserName, extra)); };
+  if (window.prettier && window.prettierPlugins) return go();
+  if (window.loadPrettierPlugins) return window.loadPrettierPlugins().then(go);
+  return Promise.reject(new Error('Prettier is not available'));
+}
 
 var DEFAULT_EDITOR_PREFS = {
   theme: 'vs-dark',
@@ -74,8 +119,6 @@ var DEFAULT_EDITOR_PREFS = {
   toolbarIconOnly: false,
   rubocopLintEnabled: true,
   prettierPrintWidth: 80,
-  prettierTabWidth: 2,
-  prettierUseTabs: false,
   prettierSemi: true,
   prettierSingleQuote: false,
   prettierTrailingComma: 'all',
@@ -89,28 +132,11 @@ var DEFAULT_EDITOR_PREFS = {
   branchStateRestore: true
 };
 
-// Detect the minimum number of leading spaces used for indentation across all
-// indented lines in the code. Returns 0 if no space-indented lines are found
-// (e.g. file already uses tabs or has no indented lines).
-function detectIndentWidth(code) {
-  var min = Infinity;
-  code.split('\n').forEach(function(line) {
-    if (!line.trim()) return;
-    var m = line.match(/^( +)/);
-    if (m) min = Math.min(min, m[1].length);
-  });
-  return min === Infinity ? 0 : min;
-}
-
-// Convert leading space-based indentation to tabs using the detected unit size.
-function spacesToTabs(code, indentSize) {
-  var unit = ' '.repeat(indentSize);
-  return code.split('\n').map(function(line) {
-    var tabs = '';
-    while (line.startsWith(unit)) { tabs += '\t'; line = line.slice(unit.length); }
-    return tabs + line;
-  }).join('\n');
-}
+// Indentation of formatted output is the formatter's job, not a post-pass:
+// Prettier is given useTabs/tabWidth from the editor's own settings, and Ruby
+// indentation comes from the project's .rubocop.yml. Monaco's built-in
+// "Convert Indentation to Tabs / to Spaces" commands (F1) cover converting a
+// file that is already open, using its own indentation guesser.
 
 function diffLines(oldLines, newLines) {
   var n = oldLines.length, m = newLines.length;
@@ -1018,28 +1044,11 @@ var MbeditorApp = function MbeditorApp() {
       return;
     }
 
-    var ext = tab.path.split('.').pop().toLowerCase();
-    var formatMap = {
-      'js': 'babel', 'jsx': 'babel',
-      'json': 'json',
-      'css': 'css', 'scss': 'scss',
-      'html': 'html', 'md': 'markdown'
-    };
-    var parserName = formatMap[ext];
+    var parserName = prettierParserFor(tab.path);
 
     if (parserName && window.prettier && window.prettierPlugins) {
       var prefs = EditorStore.getState().editorPrefs || DEFAULT_EDITOR_PREFS;
-      window.prettier.format(tab.content, {
-        parser: parserName,
-        plugins: Object.values(window.prettierPlugins),
-        printWidth: prefs.prettierPrintWidth != null ? prefs.prettierPrintWidth : 80,
-        tabWidth: prefs.tabSize != null ? prefs.tabSize : 2,
-        useTabs: !(prefs.insertSpaces),
-        semi: prefs.prettierSemi !== false,
-        singleQuote: !!prefs.prettierSingleQuote,
-        trailingComma: prefs.prettierTrailingComma || 'all',
-        bracketSpacing: prefs.prettierBracketSpacing !== false
-      }).then(function () {
+      window.prettier.format(tab.content, prettierOptions(prefs, parserName)).then(function () {
         var currentPane = EditorStore.getState().panes.find(function (p) {
           return p.id === paneId;
         });
@@ -2671,26 +2680,9 @@ var MbeditorApp = function MbeditorApp() {
         .then(function (res) { return (res && res.content) || null; })
         ["catch"](function () { return null; });
     }
-    var ext = tab.path.split('.').pop().toLowerCase();
-    var parserMap = { 'js': 'babel', 'jsx': 'babel', 'json': 'json', 'css': 'css', 'scss': 'scss', 'html': 'html', 'md': 'markdown' };
-    var parserName = parserMap[ext];
+    var parserName = prettierParserFor(tab.path);
     if (!parserName) return Promise.resolve(null);
-    var run = function () {
-      return window.prettier.format(tab.content, {
-        parser: parserName,
-        plugins: Object.values(window.prettierPlugins),
-        printWidth: editorPrefs.prettierPrintWidth != null ? editorPrefs.prettierPrintWidth : 80,
-        tabWidth: editorPrefs.prettierTabWidth != null ? editorPrefs.prettierTabWidth : 2,
-        useTabs: !!editorPrefs.prettierUseTabs,
-        semi: editorPrefs.prettierSemi !== false,
-        singleQuote: !!editorPrefs.prettierSingleQuote,
-        trailingComma: editorPrefs.prettierTrailingComma || 'all',
-        bracketSpacing: editorPrefs.prettierBracketSpacing !== false
-      })["catch"](function () { return null; });
-    };
-    if (window.prettier && window.prettierPlugins) return run();
-    if (window.loadPrettierPlugins) return window.loadPrettierPlugins().then(run)["catch"](function () { return null; });
-    return Promise.resolve(null);
+    return runPrettier(tab.content, editorPrefs, parserName)["catch"](function () { return null; });
   };
 
   var handleSave = function handleSave(paneId, tab) {
@@ -2991,132 +2983,141 @@ var MbeditorApp = function MbeditorApp() {
       });
   };
 
-  var handleFormat = function handleFormat() {
-    if (!activeTab) return;
+  // Format one tab's content.
+  //
+  // Resolves to the formatted string, or to null when no formatter covers this
+  // file type (the caller then decides whether to fall back to a re-indent).
+  // Rejects when a formatter ran and failed, so the reason reaches the user
+  // rather than the button appearing to do nothing.
+  var formatTabContent = function formatTabContent(tab, prefs) {
+    prefs = prefs || editorPrefs;
+    if (isRubyPath(tab.path) || tab.path.endsWith('.rake')) {
+      if (!rubocopAvailable) return Promise.reject(new Error("RuboCop is not available for this workspace."));
+      // RuboCop's output is taken as-is. Ruby indentation belongs to the
+      // project's .rubocop.yml (Layout/IndentationStyle and friends), so
+      // rewriting it here would fight the linter that is about to be run over
+      // the same file. The old code tried the opposite — converting the source
+      // to tabs *before* handing it over — which RuboCop simply discarded.
+      return formatRubySource(tab.path, tab.content).then(function (res) {
+        return (res && res.content) || null;
+      });
+    }
 
-    var isRubyLang = activeTab.path.endsWith('.rb') || activeTab.path.endsWith('.rake') || activeTab.path.endsWith('.gemspec') || activeTab.path.endsWith("Rakefile") || activeTab.path.endsWith("Gemfile");
+    var parserName = prettierParserFor(tab.path);
+    if (!parserName) return Promise.resolve(null);
+    return runPrettier(tab.content, prefs, parserName);
+  };
 
-    if (isRubyLang && !rubocopAvailable) {
-      EditorStore.setStatus("RuboCop is not available for this workspace.", "warning");
-      return;
-    }
+  // Write formatted content back to a tab, dirty and unsaved — the user decides
+  // when to save. EditorPanel applies it through executeEdits, so undo works.
+  var applyFormattedContent = function applyFormattedContent(paneId, tabId, formatted) {
+    EditorStore.setState({
+      panes: EditorStore.getState().panes.map(function (p) {
+        if (p.id !== paneId) return p;
+        return _extends({}, p, { tabs: p.tabs.map(function (t) {
+          return t.id === tabId
+            ? _extends({}, t, { content: formatted, dirty: true, externalContentVersion: (t.externalContentVersion || 0) + 1 })
+            : t;
+        }) });
+      })
+    });
+  };
 
-    if (isRubyLang) {
-      setLoading(function (prev) {
-        return _extends({}, prev, { format: true });
-      });
-      EditorStore.setStatus("Formatting...", "info");
-      var originalContent = activeTab.content;
-      var codeToFormat = originalContent;
-      if (editorPrefs.insertSpaces === false) {
-        var detectedWidth = detectIndentWidth(originalContent);
-        if (detectedWidth > 0) codeToFormat = spacesToTabs(originalContent, detectedWidth);
-      }
-      formatRubySource(activeTab.path, codeToFormat).then(function (res) {
-        if (res.content) {
-          // Update content and mark dirty — user decides when to save.
-          // The executeEdits path in EditorPanel preserves the undo stack.
-          var newPanes = EditorStore.getState().panes.map(function (p) {
-            if (p.id === focusedPane.id) return _extends({}, p, { tabs: p.tabs.map(function (t) {
-                return t.id === activeTab.id ? _extends({}, t, { content: res.content, dirty: true, externalContentVersion: (t.externalContentVersion || 0) + 1 }) : t;
-              }) });
-            return p;
-          });
-          EditorStore.setState({ panes: newPanes });
-
-          // Highlight changed lines briefly
-          var monacoEditor = window.__mbeditorActiveEditor;
-          if (monacoEditor && res.content !== originalContent) {
-            var changedLineNums = diffLines(originalContent.split('\n'), res.content.split('\n'));
-            if (changedLineNums.length > 0) {
-              var decorations = changedLineNums.map(function(ln) {
-                return { range: new monaco.Range(ln, 1, ln, 1), options: { isWholeLine: true, className: 'mbeditor-format-changed' } };
-              });
-              var ids = monacoEditor.deltaDecorations([], decorations);
-              setTimeout(function() { monacoEditor.deltaDecorations(ids, []); }, 3000);
-            }
-          }
+  var highlightFormatChanges = function highlightFormatChanges(before, after) {
+    var monacoEditor = window.__mbeditorActiveEditor;
+    if (!monacoEditor || before === after) return;
+    var changedLineNums = diffLines(before.split('\n'), after.split('\n'));
+    if (!changedLineNums.length) return;
+    var ids = monacoEditor.deltaDecorations([], changedLineNums.map(function (ln) {
+      return { range: new monaco.Range(ln, 1, ln, 1), options: { isWholeLine: true, className: 'mbeditor-format-changed' } };
+    }));
+    setTimeout(function () { monacoEditor.deltaDecorations(ids, []); }, 3000);
+  };
+
+  var handleFormat = function handleFormat() {
+    if (!activeTab) return;
+
+    var tab = activeTab;
+    var paneId = focusedPane.id;
+    var originalContent = tab.content;
+
+    setLoading(function (prev) { return _extends({}, prev, { format: true }); });
+    EditorStore.setStatus("Formatting " + tab.name + "...", "info");
+
+    formatTabContent(tab).then(function (formatted) {
+      if (formatted == null) {
+        // No formatter for this file type — re-indent with Monaco instead.
+        var monacoEditor = window.__mbeditorActiveEditor;
+        var reindentAction = monacoEditor && monacoEditor.getAction('editor.action.reindentLines');
+        if (!reindentAction) {
+          EditorStore.setStatus("No formatter for " + tab.name + ".", "warning");
+          return;
         }
-        EditorStore.setStatus("Formatted (Unsaved)", "success");
-        GitService.fetchStatus();
-      })["catch"](function (err) {
-        return EditorStore.setStatus("Format failed: " + err.message, "error");
-      })["finally"](function () {
-        return setLoading(function (prev) {
-          return _extends({}, prev, { format: false });
+        return reindentAction.run().then(function () {
+          EditorStore.setStatus("Re-indented (Unsaved)", "success");
         });
+      }
+      if (formatted !== originalContent) {
+        applyFormattedContent(paneId, tab.id, formatted);
+        highlightFormatChanges(originalContent, formatted);
+      }
+      EditorStore.setStatus(formatted === originalContent ? "Already formatted" : "Formatted (Unsaved)", "success");
+      GitService.fetchStatus();
+    })["catch"](function (err) {
+      EditorStore.setStatus("Format failed: " + (err && err.message ? err.message : err), "error");
+    })["finally"](function () {
+      setLoading(function (prev) { return _extends({}, prev, { format: false }); });
+    });
+  };
+
+  // Format every open document across all panes.
+  //
+  // Each tab is formatted independently and a failure is collected rather than
+  // thrown, so one unparseable file cannot stop the rest. Virtual tabs (diffs,
+  // settings, the changelog) have no path on disk and are skipped.
+  var handleFormatAll = function handleFormatAll() {
+    var targets = [];
+    EditorStore.getState().panes.forEach(function (p) {
+      p.tabs.forEach(function (t) {
+        if (t.path && !t.path.startsWith('mbeditor://') && t.path !== '__settings__' && typeof t.content === 'string') {
+          targets.push({ paneId: p.id, tab: t });
+        }
       });
+    });
+
+    if (!targets.length) {
+      EditorStore.setStatus("No open documents to format.", "warning");
       return;
     }
 
-    // Attempt Prettier Formatting
-    var ext = activeTab.path.split('.').pop().toLowerCase();
-    var formatMap = {
-      'js': 'babel', 'jsx': 'babel',
-      'json': 'json',
-      'css': 'css', 'scss': 'scss',
-      'html': 'html', 'md': 'markdown'
-    };
-    var parserName = formatMap[ext];
+    setLoading(function (prev) { return _extends({}, prev, { format: true }); });
+    EditorStore.setStatus("Formatting " + targets.length + " open document" + (targets.length === 1 ? "" : "s") + "...", "info");
 
-    if (parserName) {
-      setLoading(function (prev) {
-        return _extends({}, prev, { format: true });
-      });
-      EditorStore.setStatus("Formatting with Prettier...", "info");
-      var doFormat = function doFormat() {
-        return window.prettier.format(activeTab.content, {
-          parser: parserName,
-          plugins: Object.values(window.prettierPlugins),
-          printWidth: editorPrefs.prettierPrintWidth != null ? editorPrefs.prettierPrintWidth : 80,
-          tabWidth: editorPrefs.prettierTabWidth != null ? editorPrefs.prettierTabWidth : 2,
-          useTabs: !!editorPrefs.prettierUseTabs,
-          semi: editorPrefs.prettierSemi !== false,
-          singleQuote: !!editorPrefs.prettierSingleQuote,
-          trailingComma: editorPrefs.prettierTrailingComma || 'all',
-          bracketSpacing: editorPrefs.prettierBracketSpacing !== false
-        }).then(function (formatted) {
-          var newPanes = EditorStore.getState().panes.map(function (p) {
-            if (p.id === focusedPane.id) return _extends({}, p, { tabs: p.tabs.map(function (t) {
-                return t.id === activeTab.id ? _extends({}, t, { content: formatted, dirty: true, externalContentVersion: (t.externalContentVersion || 0) + 1 }) : t;
-              }) });
-            return p;
-          });
-          EditorStore.setState({ panes: newPanes });
-          EditorStore.setStatus("Formatted (Unsaved)", "success");
-          GitService.fetchStatus();
-        })["catch"](function (err) {
-          EditorStore.setStatus("Prettier Formatter failed: " + err.message, "error");
-        })["finally"](function () {
-          setLoading(function (prev) {
-            return _extends({}, prev, { format: false });
-          });
-        });
-      };
-      if (window.prettier && window.prettierPlugins) {
-        doFormat();
-      } else if (window.loadPrettierPlugins) {
-        window.loadPrettierPlugins().then(doFormat)["catch"](function (err) {
-          EditorStore.setStatus("Failed to load Prettier: " + err.message, "error");
-          setLoading(function (prev) { return _extends({}, prev, { format: false }); });
-        });
-      } else {
-        EditorStore.setStatus("Prettier is not available.", "warning");
-        setLoading(function (prev) { return _extends({}, prev, { format: false }); });
-      }
-      return;
-    }
+    var changed = 0;
+    var skipped = 0;
+    var failures = [];
 
-    // Fallback: Monaco re-indent using the editor's configured tabSize/insertSpaces
-    var monacoEditor = window.__mbeditorActiveEditor;
-    if (monacoEditor) {
-      var reindentAction = monacoEditor.getAction('editor.action.reindentLines');
-      if (reindentAction) {
-        reindentAction.run().then(function () {
-          EditorStore.setStatus("Formatted (Unsaved)", "success");
-        });
-      }
-    }
+    Promise.all(targets.map(function (target) {
+      return formatTabContent(target.tab).then(function (formatted) {
+        if (formatted == null) { skipped += 1; return; }
+        if (formatted === target.tab.content) return;
+        applyFormattedContent(target.paneId, target.tab.id, formatted);
+        changed += 1;
+      })["catch"](function (err) {
+        failures.push(target.tab.name + ": " + (err && err.message ? err.message.split('\n')[0] : err));
+      });
+    })).then(function () {
+      var parts = [changed + " formatted"];
+      if (skipped) parts.push(skipped + " skipped");
+      if (failures.length) parts.push(failures.length + " failed");
+      EditorStore.setStatus(
+        parts.join(", ") + (changed ? " (Unsaved)" : "") + (failures.length ? " — " + failures[0] : ""),
+        failures.length ? "error" : "success"
+      );
+      if (changed) GitService.fetchStatus();
+    })["finally"](function () {
+      setLoading(function (prev) { return _extends({}, prev, { format: false }); });
+    });
   };
 
   var TEST_CACHE_PREFIX = 'mbeditor_test_result_';
@@ -4226,10 +4227,16 @@ var MbeditorApp = function MbeditorApp() {
         React.createElement("div", { className: "statusbar-sep" }),
         React.createElement(
           "button",
-          { className: "statusbar-btn", onClick: handleFormat, disabled: loading.format || !canLintAndFormat, 'aria-busy': !!loading.format },
+          { className: "statusbar-btn", onClick: handleFormat, disabled: loading.format || !canLintAndFormat, 'aria-busy': !!loading.format, title: "Format this document" },
           !loading.format && React.createElement("i", { className: "fas fa-magic" }),
           !toolbarIconOnly && !loading.format && " Format"
         ),
+        React.createElement(
+          "button",
+          { className: "statusbar-btn", onClick: handleFormatAll, disabled: loading.format || !canLintAndFormat, 'aria-busy': !!loading.format, title: "Format all open documents" },
+          React.createElement("i", { className: "fas fa-wand-magic-sparkles" }),
+          !toolbarIconOnly && !loading.format && " Format All"
+        ),
         hasGitBranch && React.createElement(
           React.Fragment,
           null,

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

@@ -816,12 +816,58 @@
       return handled;
     });
 
+    // ── Format on paste ──────────────────────────────────────────────────────
+    //
+    // Driven from onDidPaste rather than Monaco's own `formatOnPaste` option.
+    // That option has been on by default all along and never did anything here:
+    // its contribution is present and the event fires, but it declines to run
+    // the formatter, so pasted code kept whatever indentation it was copied
+    // with. onDidPaste is public API, fires reliably, and hands over the exact
+    // pasted range — which is also what makes the two cases distinguishable:
+    //
+    //   * paste that fills the whole document (a blank file, or replacing all
+    //     of it) is formatted as a document
+    //   * a paste in the middle is formatted as a range, so Prettier reprints
+    //     the smallest enclosing statement and the rest of the file is left
+    //     byte-identical
+    //
+    // Either way the result comes back at the editor's own tab/space setting,
+    // which is the point: code copied in from a spaces project lands as tabs.
+    var pasteDisposable = editor.onDidPaste(function (e) {
+      var prefs = (typeof EditorStore !== 'undefined' && EditorStore.getState().editorPrefs) || {};
+      if (prefs.formatOnPaste === false) return;
+
+      var pasteModel = editor.getModel();
+      if (!pasteModel || pasteModel.isDisposed()) return;
+
+      var full = pasteModel.getFullModelRange();
+      var wholeDocument = e.range.startLineNumber <= full.startLineNumber &&
+                          e.range.endLineNumber >= full.endLineNumber;
+
+      var action = editor.getAction(wholeDocument ? 'editor.action.formatDocument' : 'editor.action.formatSelection');
+      if (!action) return;
+
+      if (wholeDocument) {
+        action.run()["catch"](function () { /* no formatter, or unparseable — leave it */ });
+        return;
+      }
+
+      // formatSelection works on the selection, so point it at the pasted range
+      // and put the cursor back where the paste left it.
+      var restore = editor.getSelections();
+      editor.setSelection(e.range);
+      action.run()["catch"](function () {})["finally"](function () {
+        if (restore && restore.length && !editor.getModel().isDisposed()) editor.setSelections(restore);
+      });
+    });
+
     return {
       dispose: function dispose() {
         if (keydownDisposable) keydownDisposable.dispose();
         if (emmetTabDisposable) emmetTabDisposable.dispose();
         if (jsGotoMouseDisposable) jsGotoMouseDisposable.dispose();
         if (jsGotoActionDisposable) jsGotoActionDisposable.dispose();
+        if (pasteDisposable) pasteDisposable.dispose();
         contentDisposable.dispose();
       }
     };
@@ -853,6 +899,22 @@
         jsx: monaco.languages.typescript.JsxEmit.React,
         noUnusedLocals: true
       });
+      // Hand JS formatting to Prettier alone.
+      //
+      // The TypeScript worker registers its own range formatter for
+      // 'javascript', and Monaco consults whichever provider it finds first.
+      // That gave one file two formatters that disagreed: the toolbar button
+      // went through Prettier and honoured the editor's tab settings, while
+      // Shift+Alt+F and format-on-paste got the TS worker's, which reprints at
+      // two spaces and never adds semicolons, ignoring every preference. Only
+      // formatting is switched off — completions, hovers, diagnostics, rename
+      // and the rest of the JS intelligence still come from the worker.
+      monaco.languages.typescript.javascriptDefaults.setModeConfiguration(
+        Object.assign({}, monaco.languages.typescript.javascriptDefaults.modeConfiguration, {
+          documentRangeFormattingEdits: false,
+          onTypeFormattingEdits: false
+        })
+      );
     }
 
     // ── React mini-UMD type declarations ────────────────────────────────────
@@ -1767,6 +1829,82 @@
       }).catch(function () { return []; });
     }
 
+    // ── Prettier formatting providers ────────────────────────────────────────
+    //
+    // `formatOnPaste` has been on by default for a long time and did nothing
+    // outside Ruby: Monaco acts on a paste only through a *range* formatting
+    // provider, and none was registered. Registering one here is what makes
+    // pasted blocks land correctly indented, and what formats the whole thing
+    // when the paste fills an empty file (the pasted range is then the file).
+    //
+    // Prettier's own rangeStart/rangeEnd does the narrowing — it reprints the
+    // smallest enclosing statement and leaves the rest byte-identical, so a
+    // paste in the middle of a file does not reformat the file.
+    var PRETTIER_LANGUAGE_PARSERS = {
+      javascript: 'babel', json: 'json', css: 'css',
+      scss: 'scss', less: 'less', html: 'html', markdown: 'markdown'
+    };
+
+    // One edit spanning only what actually changed. A whole-document
+    // replacement would work but throws away the cursor position and collapses
+    // undo, which on every paste is very noticeable.
+    function minimalEdit(model, oldText, newText) {
+      if (oldText === newText) return [];
+      var start = 0;
+      var maxStart = Math.min(oldText.length, newText.length);
+      while (start < maxStart && oldText.charCodeAt(start) === newText.charCodeAt(start)) start++;
+      var oldEnd = oldText.length;
+      var newEnd = newText.length;
+      while (oldEnd > start && newEnd > start && oldText.charCodeAt(oldEnd - 1) === newText.charCodeAt(newEnd - 1)) {
+        oldEnd--;
+        newEnd--;
+      }
+      return [{
+        range: monaco.Range.fromPositions(model.getPositionAt(start), model.getPositionAt(oldEnd)),
+        text: newText.slice(start, newEnd)
+      }];
+    }
+
+    function prettierEdits(model, range) {
+      var parser = PRETTIER_LANGUAGE_PARSERS[model.getLanguageId()];
+      if (!parser || typeof runPrettier !== 'function') return Promise.resolve([]);
+
+      var text = model.getValue();
+      var prefs = (typeof EditorStore !== 'undefined' && EditorStore.getState().editorPrefs) || {};
+      var extra = null;
+      if (range) {
+        extra = {
+          rangeStart: model.getOffsetAt({ lineNumber: range.startLineNumber, column: range.startColumn }),
+          rangeEnd: model.getOffsetAt({ lineNumber: range.endLineNumber, column: range.endColumn })
+        };
+      }
+
+      return runPrettier(text, prefs, parser, extra)
+        .then(function (formatted) {
+          // The model can have moved on while Prettier was working.
+          if (model.isDisposed() || model.getValue() !== text) return [];
+          return minimalEdit(model, text, formatted);
+        })
+        // A paste of half an expression will not parse. Leaving it alone is the
+        // right answer — the diagnostics path reports the syntax error.
+        ["catch"](function () { return []; });
+    }
+
+    Object.keys(PRETTIER_LANGUAGE_PARSERS).forEach(function (languageId) {
+      monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, {
+        displayName: 'Prettier',
+        provideDocumentRangeFormattingEdits: function (model, range) {
+          return prettierEdits(model, range);
+        }
+      });
+      monaco.languages.registerDocumentFormattingEditProvider(languageId, {
+        displayName: 'Prettier',
+        provideDocumentFormattingEdits: function (model) {
+          return prettierEdits(model, null);
+        }
+      });
+    });
+
     // Parameter hints while typing a call's arguments.
     monaco.languages.registerSignatureHelpProvider('ruby', {
       signatureHelpTriggerCharacters: ['(', ','],

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

@@ -93,11 +93,25 @@ axios.interceptors.request.use(function (config) {
   return config;
 });
 
+// A request we aborted ourselves also arrives here with no response, and the
+// editor cancels constantly — every keystroke supersedes the previous search,
+// every hover and completion provider aborts when the cursor moves on, and
+// opening a file aborts its own prefetch. Counting those as unreachable took
+// two cancellations to declare the server offline, so routine actions (creating
+// a file, typing in search) flashed "Server offline" until the /ping probe
+// one second later put it back. A cancellation says nothing about the server.
+function _isCanceled(error) {
+  if (!error) return false;
+  if (axios.isCancel && axios.isCancel(error)) return true;
+  return error.code === 'ERR_CANCELED' || error.name === 'CanceledError' || error.name === 'AbortError';
+}
+
 axios.interceptors.response.use(function (response) {
   ServerReachability.noteSuccess();
   return response;
 }, function (error) {
   if (error && error.mbeditorSkipped) return Promise.reject(error);
+  if (_isCanceled(error)) return Promise.reject(error);
   // No response object at all means the request never reached the server.
   if (error && !error.response) ServerReachability.noteNetworkFailure();
   else ServerReachability.noteSuccess();

data/app/controllers/mbeditor/application_controller.rb

@@ -32,17 +32,22 @@ module Mbeditor
     end
 
     # Expand path and confirm it's inside workspace_root.
-    # SafePath follows every symlink on the way — including dangling ones, which
-    # an existence walk would skip past — so a symlink inside the workspace
-    # cannot escape the sandbox regardless of whether the target exists yet
-    # (create / rename paths).
+    #
+    # Containment is judged lexically, on the path as spelled. File.expand_path
+    # collapses "..", so no request can name anything outside the workspace, and
+    # an absolute path is rejected outright.
+    #
+    # Symlinks are followed, the way a file manager does: an app that links a
+    # shared config directory or a sibling engine into its tree gets those files
+    # opening like any other. The link itself has to already exist inside the
+    # workspace, which means a developer put it there — the sandbox is about
+    # what a request may *name*, not about second-guessing the checkout.
     def resolve_path(raw)
       return nil if raw.blank?
 
       root = workspace_root.to_s
       full = File.expand_path(raw.to_s, root)
       return nil unless full.start_with?("#{root}/") || full == root
-      return nil unless SafePath.within?(root, full)
 
       full
     rescue Errno::EACCES, ArgumentError

data/app/services/mbeditor/code_search_service.rb

@@ -22,7 +22,7 @@ module Mbeditor
         root = workspace_root.to_s
         if SearchReplaceService.rg_available?
           run_rg(pattern, root, globs)
-        elsif File.exist?(File.join(root, ".git"))
+        elsif SearchReplaceService.git_tier?(root)
           run_git_grep(pattern, root, globs)
         else
           run_grep(pattern, root, globs)

data/app/services/mbeditor/git_service.rb

@@ -155,9 +155,12 @@ module Mbeditor
     # Resolve a file path safely within repo_path.  Returns full path string or
     # nil if the path escapes the root.
     #
-    # Follows symlinks (via SafePath, including dangling ones) so that a symlink
-    # inside the repo cannot escape it, mirroring
-    # ApplicationController#resolve_path.  When repo_path is not a real directory
+    # Resolves symlinks (via SafePath, including dangling ones) so that a
+    # symlink inside the repo cannot escape it.  Deliberately stricter than
+    # ApplicationController#resolve_path, which follows links out of the
+    # workspace so linked-in files open: git has nothing to say about a file
+    # outside its own repo, so there is no feature to lose here.
+    # When repo_path is not a real directory
     # (e.g. unit tests with synthetic roots) the symlink check is skipped, since
     # there is nothing on disk to resolve and repo_path is server-controlled.
     def resolve_path(repo_path, relative)

data/app/services/mbeditor/search_replace_service.rb

@@ -45,6 +45,19 @@ module Mbeditor
         AvailabilityProbe.rg_command || "rg"
       end
 
+      # Whether the git tier is usable on this workspace. The presence of a
+      # `.git` entry is not enough: a repo git refuses to open (dubious
+      # ownership under Docker, a `.git` file pointing at a gitdir that moved,
+      # a git binary missing from the server's PATH) still has one. `git grep`
+      # then fails, its stderr goes to /dev/null, and search returns instantly
+      # with nothing — silently, and with no way to tell it apart from "no
+      # matches". AvailabilityProbe.git runs `rev-parse --is-inside-work-tree`,
+      # which fails in exactly those cases, so a bad repo falls through to
+      # plain grep instead of to an empty result set.
+      def git_tier?(root)
+        File.exist?(File.join(root, ".git")) && AvailabilityProbe.git(root)
+      end
+
       # Which backend a search on this workspace will actually use. Reported by
       # GET /workspace: the difference between the tiers is 10-30x, so "why is
       # search slow" needs to be answerable without reading the source.
@@ -245,7 +258,7 @@ module Mbeditor
 
       def pick_tier(root)
         return :rg if rg_available?
-        return :git if File.exist?(File.join(root, ".git"))
+        return :git if git_tier?(root)
 
         :grep
       end

data/lib/mbeditor/rack/silence_ping_request.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/logger_silence"
+require "logger"
 require "uri"
 
 module Mbeditor
@@ -18,7 +19,14 @@ module Mbeditor
         if root_request?(env, path)
           @app.call(env)
         elsif mbeditor_request?(path) || cable_request?(path) || editor_asset_request?(env, path)
-          Rails.logger.silence { @app.call(env) }
+          # Silence to WARN, not the default ERROR. The point is to hide Rails'
+          # own request lines ("Started GET ...", "Completed 200 ..."), which are
+          # INFO — but the default swallows everything below ERROR, including
+          # anything a host app logs from inside authenticate_with or
+          # user_name_callback. Those procs run within this request, so a
+          # developer debugging their own hook with Rails.logger.warn saw
+          # nothing at all and had no way to know why.
+          Rails.logger.silence(::Logger::WARN) { @app.call(env) }
         else
           @app.call(env)
         end

data/lib/mbeditor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mbeditor
-  VERSION = "0.12.5"
+  VERSION = "0.12.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.12.6
 platform: ruby
 authors:
 - Oliver Noonan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails