mbeditor 0.13.0 → 0.13.1

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

@@ -112,6 +112,10 @@ var ProblemsPanel = (function () {
   var Panel = function ProblemsPanelComponent(_ref) {
     var onClose = _ref.onClose;
     var onOpenFile = _ref.onOpenFile;
+    // Called after `-a` has rewritten files on disk, so the app can re-read
+    // every open tab. Nothing else would: the write came from a subprocess,
+    // not from the editor, so the buffers and their markers are stale.
+    var onFilesRewritten = _ref.onFilesRewritten;
 
     var _problems = React.useState(collect);
     var problems = _problems[0], setProblems = _problems[1];
@@ -190,7 +194,10 @@ var ProblemsPanel = (function () {
       if (running) return;
       setRunning(mode);
       FileService.runRubocop(mode)
-        .then(function (data) { setWorkspace(data); })
+        .then(function (data) {
+          setWorkspace(data);
+          if (mode === 'autocorrect' && data && data.ok && onFilesRewritten) onFilesRewritten();
+        })
         ["catch"](function (e) {
           var res = e && e.response && e.response.data;
           setWorkspace(res || { ok: false, error: (e && e.message) || 'RuboCop failed', files: [] });
@@ -283,6 +290,25 @@ var ProblemsPanel = (function () {
         }).filter(function (entry) { return entry.markers.length > 0; })
       : problems.byFile;
 
+    // The workspace run and the marker set are different scopes, but they render
+    // in one panel under one set of severity chips. Counting only the markers
+    // made the header disagree with its own body: click RuboCop, get 400
+    // offenses listed under chips reading 0 / 0 / 0, and hiding "warning" left
+    // every workspace warning on screen. The chips describe what the panel is
+    // showing, so they have to cover both — and the filter has to reach both.
+    var wsFiles = (workspace && workspace.files) || [];
+    var wsCounts = { error: 0, warning: 0, info: 0 };
+    var wsShown = [];
+    wsFiles.forEach(function (file) {
+      var kept = [];
+      file.offenses.forEach(function (o) {
+        var kind = COP_SEVERITY_KIND[o.severity] || 'info';
+        wsCounts[kind] += 1;
+        if (severities[kind]) kept.push(o);
+      });
+      if (kept.length) wsShown.push({ path: file.path, offenses: kept });
+    });
+
     var total = problems.errors.length + problems.warnings.length + problems.infos.length;
 
     return React.createElement(
@@ -304,9 +330,9 @@ var ProblemsPanel = (function () {
           'div',
           { className: 'ide-problems-severity-filter' },
           [
-            { kind: 'error', count: problems.errors.length },
-            { kind: 'warning', count: problems.warnings.length },
-            { kind: 'info', count: problems.infos.length }
+            { kind: 'error', count: problems.errors.length + wsCounts.error },
+            { kind: 'warning', count: problems.warnings.length + wsCounts.warning },
+            { kind: 'info', count: problems.infos.length + wsCounts.info }
           ].map(function (s) {
             var on = severities[s.kind];
             return React.createElement(
@@ -342,7 +368,9 @@ var ProblemsPanel = (function () {
             disabled: !!running || !workspace || !workspace.correctable,
             title: workspace && workspace.correctable
               ? 'Safe-autocorrect ' + workspace.correctable + ' offense(s) and rerun'
-              : 'Run RuboCop first',
+              : workspace
+                ? 'Nothing left that safe autocorrect can fix'
+                : 'Run RuboCop first',
             onClick: function () { runRubocop('autocorrect'); }
           },
             React.createElement('i', { className: running === 'autocorrect' ? 'fas fa-spinner fa-spin' : 'fas fa-magic' }),
@@ -378,9 +406,9 @@ var ProblemsPanel = (function () {
           { className: 'ide-problems-workspace' },
           workspace.error
             ? React.createElement('div', { className: 'ide-problems-empty' }, 'RuboCop: ' + workspace.error)
-            : (workspace.files || []).length === 0
+            : wsFiles.length === 0
               ? React.createElement('div', { className: 'ide-problems-empty' }, 'RuboCop found no offenses in the workspace')
-              : workspace.files.map(function (file) {
+              : wsShown.map(function (file) {
                   return React.createElement(
                     'div',
                     { className: 'ide-problems-file', key: 'ws:' + file.path },

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

@@ -23,6 +23,100 @@ function saveFavourites(list) {
   try { localStorage.setItem(FAVS_KEY, JSON.stringify(list)); } catch (e) {}
 }
 
+// ── Ranking ────────────────────────────────────────────────────────────────
+// Module scope, not component scope, so `rankResults` can be exercised without
+// rendering — see script/check-quick-open-ranking.mjs.
+
+// Priority tier for a file path: lower = shown first.
+// Order: controller > model > helper > concern > view > job > other > noise
+function getFilePriority(path) {
+  var p = (path || '').toLowerCase();
+  if (p.indexOf('/controllers/') >= 0) return 1;
+  if (p.indexOf('/models/')      >= 0) return 2;
+  if (p.indexOf('/helpers/')     >= 0) return 3;
+  if (p.indexOf('/concerns/')    >= 0) return 4;
+  if (p.indexOf('/views/')       >= 0) return 5;
+  if (p.indexOf('/jobs/')        >= 0) return 6;
+  // Deprioritise: migrations, schema, compiled assets, vendor, lock files
+  if (p.indexOf('/migrate/')  >= 0 || p.indexOf('schema.rb') >= 0) return 90;
+  if (p.indexOf('/public/')   >= 0 || p.indexOf('/vendor/')   >= 0) return 91;
+  if (p.slice(-7)  === '.min.js' || p.slice(-8) === '.min.css' ||
+      p.slice(-4)  === '.map'    || p.slice(-5) === '.lock')        return 92;
+  return 50;
+}
+
+// Recently opened files, most recent first, as a path -> rank lookup. Built
+// once per query rather than per comparison, since the sort calls this for
+// every pair.
+function recentRanks() {
+  var ranks = {};
+  var recent = (typeof TabManager !== 'undefined' && TabManager.getRecentFiles)
+    ? TabManager.getRecentFiles() : [];
+  recent.forEach(function (entry, index) {
+    var path = typeof entry === 'string' ? entry : (entry && entry.path);
+    if (path && !(path in ranks)) ranks[path] = index;
+  });
+  return ranks;
+}
+
+// Match relevance within a priority tier:
+//   exact basename > basename prefix > basename substring > path substring > fuzzy-only.
+// FUZZY_ONLY is the bucket everything MiniSearch matched approximately lands
+// in — a typo'd or transposed query hits nothing literally, so an exact match
+// can never be demoted by loosening the index search.
+var FUZZY_ONLY = 4;
+function getMatchRelevance(result, q) {
+  if (!q) return FUZZY_ONLY;
+  var name = (result.name || (result.path || '').split('/').pop() || '').toLowerCase();
+  var lq = q.toLowerCase();
+  if (name === lq)            return 0;
+  if (name.slice(0, lq.length) === lq) return 1;
+  if (name.indexOf(lq) >= 0)  return 2;
+  if ((result.path || '').toLowerCase().indexOf(lq) >= 0) return 3;
+  return FUZZY_ONLY;
+}
+
+// Filter SearchService hits by type and order them for display.
+// Precedence:
+//   1. files before folders — a folder is never what Ctrl+P is for, and as a
+//      tier below match quality an exactly-named folder used to outrank every
+//      file that matched
+//   2. match quality (see getMatchRelevance), so a worse match can never jump
+//      the queue however recently it was opened
+//   3. MiniSearch's own score, but only within the fuzzy-only bucket: nothing
+//      there matched literally, so edit distance is the only signal for which
+//      near-miss the user meant
+//   4. how recently the file was opened, most recent first
+//   5. the static file-type tier (controller > model > … > noise)
+//
+// Recency sits above the type tier deliberately: when two files match a query
+// equally well, the one you were just working in is almost always the one you
+// meant, and that beats a guess made from the directory name. Files never
+// opened all tie here and fall through to the type tier, which is what orders
+// the bulk of a cold result list.
+//
+// JS sort is stable in modern engines, so MiniSearch's own relevance order
+// remains the final tiebreaker.
+function rankResults(res, query, showFolders) {
+  var filtered = showFolders ? res.slice() : res.filter(function (r) { return r.type !== 'dir'; });
+  var ranks = recentRanks();
+  var NEVER_OPENED = Infinity;
+  filtered.sort(function (a, b) {
+    var aDir = a.type === 'dir' ? 1 : 0;
+    var bDir = b.type === 'dir' ? 1 : 0;
+    if (aDir !== bDir) return aDir - bDir;
+    var aRelevance = getMatchRelevance(a, query);
+    var bRelevance = getMatchRelevance(b, query);
+    if (aRelevance !== bRelevance) return aRelevance - bRelevance;
+    if (aRelevance === FUZZY_ONLY && a.score !== b.score) return (b.score || 0) - (a.score || 0);
+    var aRecent = a.path in ranks ? ranks[a.path] : NEVER_OPENED;
+    var bRecent = b.path in ranks ? ranks[b.path] : NEVER_OPENED;
+    if (aRecent !== bRecent) return aRecent - bRecent;
+    return getFilePriority(a.path) - getFilePriority(b.path);
+  });
+  return filtered;
+}
+
 // ── Component ──────────────────────────────────────────────────────────────
 
 var QuickOpenDialog = function QuickOpenDialog(_ref) {
@@ -76,49 +170,6 @@ var QuickOpenDialog = function QuickOpenDialog(_ref) {
     if (inputRef.current) inputRef.current.focus();
   };
 
-  // Priority tier for a file path: lower = shown first.
-  // Order: controller > model > helper > concern > view > job > other > noise
-  function getFilePriority(path) {
-    var p = (path || '').toLowerCase();
-    if (p.indexOf('/controllers/') >= 0) return 1;
-    if (p.indexOf('/models/')      >= 0) return 2;
-    if (p.indexOf('/helpers/')     >= 0) return 3;
-    if (p.indexOf('/concerns/')    >= 0) return 4;
-    if (p.indexOf('/views/')       >= 0) return 5;
-    if (p.indexOf('/jobs/')        >= 0) return 6;
-    // Deprioritise: migrations, schema, compiled assets, vendor, lock files
-    if (p.indexOf('/migrate/')  >= 0 || p.indexOf('schema.rb') >= 0) return 90;
-    if (p.indexOf('/public/')   >= 0 || p.indexOf('/vendor/')   >= 0) return 91;
-    if (p.slice(-7)  === '.min.js' || p.slice(-8) === '.min.css' ||
-        p.slice(-4)  === '.map'    || p.slice(-5) === '.lock')        return 92;
-    return 50;
-  }
-
-  // Recently opened files, most recent first, as a path -> rank lookup. Built
-  // once per query rather than per comparison, since the sort calls this for
-  // every pair.
-  function recentRanks() {
-    var ranks = {};
-    var recent = (typeof TabManager !== 'undefined' && TabManager.getRecentFiles)
-      ? TabManager.getRecentFiles() : [];
-    recent.forEach(function (entry, index) {
-      var path = typeof entry === 'string' ? entry : (entry && entry.path);
-      if (path && !(path in ranks)) ranks[path] = index;
-    });
-    return ranks;
-  }
-
-  // Match relevance within a priority tier: exact basename > prefix > substring > other.
-  function getMatchRelevance(result, q) {
-    if (!q) return 3;
-    var name = (result.name || (result.path || '').split('/').pop() || '').toLowerCase();
-    var lq = q.toLowerCase();
-    if (name === lq)            return 0;
-    if (name.slice(0, lq.length) === lq) return 1;
-    if (name.indexOf(lq) >= 0)  return 2;
-    return 3;
-  }
-
   var getQuickOpenIcon = function getQuickOpenIcon(path, name, type) {
     if (type === 'dir') {
       return React.createElement('i', { className: 'fas fa-folder quick-open-result-icon quick-open-folder-icon', 'aria-hidden': 'true' });
@@ -143,37 +194,7 @@ var QuickOpenDialog = function QuickOpenDialog(_ref) {
     // path in the workspace ran on every keystroke, between the keypress and
     // the character appearing.
     var timer = setTimeout(function () {
-      var res = SearchService.searchFiles(query);
-      // Filter by type: always include files; include dirs only when showFolders is on
-      var filtered = showFolders ? res : res.filter(function(r) { return r.type !== 'dir'; });
-      // Sort, in order of precedence:
-      //   1. match quality — exact basename > prefix > substring > other, so a
-      //      worse match can never jump the queue however recently it was opened
-      //   2. how recently the file was opened, most recent first
-      //   3. the static file-type tier (controller > model > … > noise)
-      //
-      // Recency sits above the type tier deliberately: when two files match a
-      // query equally well, the one you were just working in is almost always
-      // the one you meant, and that beats a guess made from the directory name.
-      // Files never opened all tie here and fall through to the type tier, which
-      // is what orders the bulk of a cold result list.
-      //
-      // Directories keep their +100 penalty inside the type tier so files still
-      // come first. JS sort is stable in modern engines, so MiniSearch's own
-      // relevance order remains the final tiebreaker.
-      var ranks = recentRanks();
-      var NEVER_OPENED = Infinity;
-      filtered.sort(function(a, b) {
-        var aRelevance = getMatchRelevance(a, query);
-        var bRelevance = getMatchRelevance(b, query);
-        if (aRelevance !== bRelevance) return aRelevance - bRelevance;
-        var aRecent = a.path in ranks ? ranks[a.path] : NEVER_OPENED;
-        var bRecent = b.path in ranks ? ranks[b.path] : NEVER_OPENED;
-        if (aRecent !== bRecent) return aRecent - bRecent;
-        var aPriority = getFilePriority(a.path) + (a.type === 'dir' ? 100 : 0);
-        var bPriority = getFilePriority(b.path) + (b.type === 'dir' ? 100 : 0);
-        return aPriority - bPriority;
-      });
+      var filtered = rankResults(SearchService.searchFiles(query), query, showFolders);
       setResults(filtered.slice(0, 200));
       setSelectedIndex(0);
     }, 120);
@@ -395,7 +416,7 @@ var QuickOpenDialog = function QuickOpenDialog(_ref) {
               }),
               results.length === 0 && React.createElement(
                 'div',
-                { style: { padding: '12px 16px', color: '#666', fontSize: '12px' } },
+                { style: { padding: '14px 18px', color: '#666', fontSize: '14px' } },
                 'No matching files.'
               )
             )
@@ -404,4 +425,5 @@ var QuickOpenDialog = function QuickOpenDialog(_ref) {
   );
 };
 
+QuickOpenDialog.rankResults = rankResults;
 window.QuickOpenDialog = QuickOpenDialog;

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

@@ -1484,7 +1484,13 @@
             cases: {
               '$2~(?i:SQL)':            { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'sql' },
               '$2~(?i:HTML?|ERB)':      { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'html' },
-              '$2~(?i:JS|JAVASCRIPT)':  { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'javascript' },
+              // JSX rides the javascript tokenizer: Monaco registers no
+              // separate jsx language, and its TS-derived grammar lexes JSX
+              // bodies fine. The guard is anchored (^...$), so plain `JS`
+              // never matched `JSX` and it fell through to the generic
+              // heredoc — the whole block painted as one string.
+              '$2~(?i:JSX?|JAVASCRIPT)': { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'javascript' },
+              '$2~(?i:TSX?|TYPESCRIPT)': { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'typescript' },
               '$2~(?i:CSS)':            { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'css' },
               '$2~(?i:SCSS)':           { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'scss' },
               '$2~(?i:JSON)':           { token: 'string.heredoc.delimiter', next: '@heredocEmbedded.$2', nextEmbedded: 'json' },

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

@@ -276,30 +276,21 @@ var FileService = (function () {
 
   // line (1-based, optional) narrows the run to the single test at that line;
   // the server ignores it unless `path` IS the test file.
-  // Server-reported ceilings (seconds), seeded from /workspace. The request
-  // timeout is derived from them rather than hard-coded: two independent
+  // Server-reported ceiling (seconds), seeded from /workspace. The request
+  // timeout is derived from it rather than hard-coded: two independent
   // numbers meant that raising config.test_timeout past the client's own cap
   // made the browser abort a run the server was still executing, and the user
   // saw a generic network error instead of the server's message.
-  var testTimeouts = { test: 180, testAll: 1800 };
-  function setTestTimeouts(t) {
-    if (t && t.test > 0) testTimeouts.test = t.test;
-    if (t && t.testAll > 0) testTimeouts.testAll = t.testAll;
-  }
-  // Margin for boot, JSON encoding and the trip back, so the server's own
-  // timeout is always the one that fires first and reports why.
-  function requestTimeout(seconds) { return (seconds + 30) * 1000; }
+  var testTimeout = 180;
+  function setTestTimeout(seconds) { if (seconds > 0) testTimeout = seconds; }
 
   function runTests(path, line) {
     var payload = { path: path };
     if (line) payload.line = line;
+    // Margin for boot, JSON encoding and the trip back, so the server's own
+    // timeout is always the one that fires first and reports why.
     return axios.post(window.mbeditorBasePath() + '/test', payload,
-      { timeout: requestTimeout(testTimeouts.test) }).then(function(res) { return res.data; });
-  }
-
-  function runAllTests() {
-    return axios.post(window.mbeditorBasePath() + '/test_all', {},
-      { timeout: requestTimeout(testTimeouts.testAll) }).then(function(res) { return res.data; });
+      { timeout: (testTimeout + 30) * 1000 }).then(function(res) { return res.data; });
   }
 
   function ping() {
@@ -585,8 +576,7 @@ var FileService = (function () {
     rubyRename: rubyRename,
     getModelGraph: getModelGraph,
     runRubocop: runRubocop,
-    runAllTests: runAllTests,
-    setTestTimeouts: setTestTimeouts,
+    setTestTimeout: setTestTimeout,
     getExceptions: getExceptions,
     clearExceptions: clearExceptions,
     getRelatedFiles: getRelatedFiles,

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

@@ -79,13 +79,31 @@ var SearchService = (function () {
     });
   }
 
+  // Fuzziness per term: edit distance is `fuzzy * term.length` inside
+  // MiniSearch, so short terms get none (at 3 chars every 3-letter token in the
+  // tree is within one edit and the list becomes noise) and longer ones get
+  // roughly one typo per 4 characters.
+  function _fuzzyFor(term) {
+    return term.length > 3 ? 0.25 : false;
+  }
+
   // Search files (and optionally folders) in the local MiniSearch index.
+  // Fuzzy + prefix, so a misspelled or half-typed query still finds the file;
+  // ranking back in QuickOpenDialog puts exact matches first, so loosening the
+  // match here cannot demote one.
   // Also performs a case-insensitive substring scan so that partial-word
-  // queries like "project" reliably find "projects_controller.rb".
+  // queries like "project" reliably find "projects_controller.rb" — the
+  // tokenizer splits on punctuation, so a query spanning a separator
+  // ("models/user") tokenizes into terms no single token can satisfy.
   // Returns merged results; MiniSearch scored entries come first.
   function searchFiles(query) {
     if (!query) return [];
-    var msResults = _miniSearch.search(query, { prefix: true, fuzzy: false, combineWith: 'AND' });
+    var msResults = _miniSearch.search(query, {
+      prefix: true,
+      fuzzy: _fuzzyFor,
+      combineWith: 'AND',
+      boost: { name: 2 }
+    });
     // Substring fallback — catch anything MiniSearch missed
     var q = query.toLowerCase();
     var msIds = new Set(msResults.map(function(r) { return r.id; }));

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

@@ -169,7 +169,10 @@ var TabManager = (function () {
     openTab(target.path, target.name, target.line, null, false, target.col);
   }
 
-  function openTab(path, name, line, forcePaneId, isSoftOpen, col) {
+  // col/endCol are the 1-based bounds of the thing being jumped to. Pass both
+  // and the editor selects it, leaving the cursor at its end; pass col alone
+  // and it just parks the cursor there.
+  function openTab(path, name, line, forcePaneId, isSoftOpen, col, endCol) {
     if (line) _jumpOrigin = _snapshotPosition() || _jumpOrigin;
     var state = EditorStore.getState();
     var paneId = forcePaneId || state.focusedPaneId;
@@ -191,7 +194,7 @@ var TabManager = (function () {
     var existing = pane.tabs.find(function(t) { return t.path === path; });
 
     if (existing) {
-      if (line) _updateTab(paneId, path, { gotoLine: line, gotoCol: col || null });
+      if (line) _updateTab(paneId, path, { gotoLine: line, gotoCol: col || null, gotoEndCol: endCol || null });
       switchTab(paneId, path);
       if (_isMarkdownPath(path)) {
         _ensureMarkdownPreview(paneId, path, existing.name || name, existing.content || "");
@@ -217,7 +220,7 @@ var TabManager = (function () {
       isSoftOpen: isSoftOpen ? true : false,
       loading: true
     };
-    if (line) { newTab.gotoLine = line; newTab.gotoCol = col || null; }
+    if (line) { newTab.gotoLine = line; newTab.gotoCol = col || null; newTab.gotoEndCol = endCol || null; }
 
     var newPanes = state.panes.map(function(p) {
       if (p.id === paneId) {
@@ -699,7 +702,7 @@ var TabManager = (function () {
   }
 
   function clearGotoLine(paneId, path) {
-    _updateTab(paneId, path, { gotoLine: null, gotoCol: null });
+    _updateTab(paneId, path, { gotoLine: null, gotoCol: null, gotoEndCol: null });
   }
 
   // VS Code-style scratch buffer: a tab with no file behind it. Nothing is