mbeditor 0.12.9 → 0.13.1

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

@@ -90,6 +90,82 @@ var FileImport = (function () {
     return readBatch();
   }
 
+  // <input type="file"> equivalent of collectEntries. A directory pick fills
+  // webkitRelativePath with the path *below* the chosen folder, including that
+  // folder's own name; a plain multi-file pick leaves it empty.
+  function entriesFromFileList(fileList) {
+    var out = [];
+    for (var i = 0; i < (fileList || []).length; i++) {
+      var f = fileList[i];
+      out.push({ file: f, relativePath: stripLeadingSlash(f.webkitRelativePath || f.name) });
+    }
+    return {
+      entries: out.slice(0, MAX_ENTRIES),
+      truncated: out.length > MAX_ENTRIES,
+      foldersSkipped: false
+    };
+  }
+
+  // Where in the workspace does this set of files already live?
+  //
+  // A folder picked as `ux/component/` is almost never meant for the workspace
+  // root — its real home is whatever prefix makes the path resolve, e.g.
+  // `app/assets/javascripts`. So every entry's relative path is matched as a
+  // *suffix* of the existing tree: a file suffix hit means "this exact file is
+  // already there" (the replace case), a directory hit on the entry's parent
+  // means "the structure is there, this file is new". Files score higher so
+  // an exact replace target sorts above a merely plausible folder.
+  //
+  // docs: [{ path, type: 'file' | 'dir' }] — SearchService's index, which
+  // already has excluded paths removed.
+  // => [{ prefix, files, dirs, score }] best first, root ('') never included.
+  //
+  // ponytail: O(entries x docs) scan — 100 x ~2000 measures well under a
+  // frame. Index docs by basename if a tree ever makes it drag.
+  function suggestDestinations(entries, docs, limit) {
+    var scores = {};
+
+    var note = function (prefix, key) {
+      if (!prefix) return; // the root is always offered separately
+      var s = scores[prefix] || (scores[prefix] = { prefix: prefix, files: 0, dirs: 0 });
+      s[key] += 1;
+    };
+
+    // The prefix that makes `suffix` land on `path`, or null if it doesn't.
+    var prefixFor = function (path, suffix) {
+      if (!suffix || path.length <= suffix.length) return null;
+      var cut = path.length - suffix.length;
+      if (path.charAt(cut - 1) !== '/') return null;
+      return path.slice(cut) === suffix ? path.slice(0, cut - 1) : null;
+    };
+
+    (entries || []).forEach(function (e) {
+      var rel = stripLeadingSlash(e.relativePath);
+      var slash = rel.lastIndexOf('/');
+      var dir = slash === -1 ? '' : rel.slice(0, slash);
+
+      (docs || []).forEach(function (doc) {
+        if (doc.type === 'file') {
+          note(prefixFor(doc.path, rel), 'files');
+        } else if (dir) {
+          note(prefixFor(doc.path, dir), 'dirs');
+        }
+      });
+    });
+
+    return Object.keys(scores)
+      .map(function (k) {
+        var s = scores[k];
+        s.score = s.files * 2 + s.dirs;
+        return s;
+      })
+      .sort(function (a, b) {
+        if (b.score !== a.score) return b.score - a.score;
+        return a.prefix.length - b.prefix.length;
+      })
+      .slice(0, limit || 5);
+  }
+
   function stripLeadingSlash(p) {
     return String(p || '').replace(/^\/+/, '');
   }
@@ -136,6 +212,8 @@ var FileImport = (function () {
     MAX_ENTRIES: MAX_ENTRIES,
     hasExternalFiles: hasExternalFiles,
     collectEntries: collectEntries,
+    entriesFromFileList: entriesFromFileList,
+    suggestDestinations: suggestDestinations,
     joinPath: joinPath,
     buildFormData: buildFormData,
     conflictedEntries: conflictedEntries

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

@@ -106,39 +106,90 @@ function _isCanceled(error) {
   return error.code === 'ERR_CANCELED' || error.name === 'CanceledError' || error.name === 'AbortError';
 }
 
+// A timeout is not an unreachable server, even though axios reports both the
+// same way — with no `response`. ECONNABORTED means the request went out and
+// the server had not answered *yet*, which is exactly what a busy dev server
+// does when a burst of saves queues behind git and tree work. Counting it as a
+// network failure declared the editor offline at the precise moment the server
+// was alive but loaded, and going offline then suppressed the very background
+// polls that would have proved it up — so it stayed "disconnected" until the
+// next /ping probe. A genuinely dead server still registers: a refused
+// connection or an unresolvable host fails immediately rather than timing out.
+function _isTimeout(error) {
+  if (!error) return false;
+  return error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT' ||
+    /timeout/i.test(error.message || '');
+}
+
 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);
+  // Neither success nor failure: a timeout is no evidence either way, so it
+  // must not clear the failure counter any more than it may advance it.
+  if (_isTimeout(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();
   return Promise.reject(error);
 });
 
-// Surface pending-migration errors as a dismissible banner instead of silently failing.
-axios.interceptors.response.use(null, function(error) {
-  if (error.response && error.response.data && error.response.data.pending_migration_error) {
-    var bannerId = 'mbeditor-migration-banner';
-    if (!document.getElementById(bannerId)) {
-      var banner = document.createElement('div');
-      banner.id = bannerId;
-      banner.style.cssText = [
-        'position:fixed', 'top:0', 'left:0', 'right:0', 'z-index:99999',
-        'background:#f1c40f', 'color:#1e1e1e', 'font-family:system-ui,sans-serif',
-        'font-size:13px', 'padding:8px 16px', 'display:flex',
-        'align-items:center', 'gap:12px'
-      ].join(';');
-      banner.innerHTML =
+// Pending-migration warning.
+//
+// The editor keeps working while migrations are pending — the server-side
+// bypass (Mbeditor::Rack::PendingMigrationBypass) is what makes that true — so
+// this is purely informational now. It is driven by a response *header* rather
+// than by a failed request, for two reasons: after the bypass there is no
+// failed request left to hang it on, and a header rides every response, so a
+// migration created mid-session raises the banner too, and running the
+// migration clears it without a reload.
+//
+// The old failed-response trigger is kept alongside: a PendingMigrationError
+// raised somewhere the bypass does not cover still shows the banner.
+var MIGRATION_BANNER_ID = 'mbeditor-migration-banner';
+
+function _showMigrationBanner() {
+  if (!document.body || document.getElementById(MIGRATION_BANNER_ID)) return;
+  var banner = document.createElement('div');
+  banner.id = MIGRATION_BANNER_ID;
+  banner.style.cssText = [
+    'position:fixed', 'top:0', 'left:0', 'right:0', 'z-index:99999',
+    'background:#f1c40f', 'color:#1e1e1e', 'font-family:system-ui,sans-serif',
+    'font-size:13px', 'padding:8px 16px', 'display:flex',
+    'align-items:center', 'gap:12px'
+  ].join(';');
+  banner.innerHTML =
         '<strong>Pending migrations detected.</strong>' +
         ' Run <code style="background:rgba(0,0,0,.15);padding:1px 5px;border-radius:3px">rails db:migrate</code>' +
-        ' then reload — editor is still available.' +
+        ' then reload — editing still works in the meantime.' +
         '<button onclick="this.parentNode.remove()" style="margin-left:auto;background:none;border:none;' +
         'cursor:pointer;font-size:16px;line-height:1;padding:0 4px" aria-label="Dismiss">\u00d7</button>';
-      document.body.prepend(banner);
-    }
+  document.body.prepend(banner);
+}
+
+function _hideMigrationBanner() {
+  var existing = document.getElementById(MIGRATION_BANNER_ID);
+  if (existing) existing.remove();
+}
+
+// Mirrors Mbeditor::Rack::PendingMigrationBypass::PENDING_HEADER. Absent means
+// the check passed, so the banner is cleared as soon as the migration is run —
+// no reload needed.
+function _notePendingMigrationHeader(response) {
+  if (!response || !response.headers) return;
+  if (response.headers['x-mbeditor-pending-migration']) _showMigrationBanner();
+  else _hideMigrationBanner();
+}
+
+axios.interceptors.response.use(function (response) {
+  _notePendingMigrationHeader(response);
+  return response;
+}, function (error) {
+  if (error && error.response && error.response.data &&
+      error.response.data.pending_migration_error) {
+    _showMigrationBanner();
   }
   return Promise.reject(error);
 });
@@ -158,6 +209,9 @@ var FileService = (function () {
   // asked for, so it can be skipped while the server is unreachable.
   function getTree(opts) {
     var cfg = (opts && opts.background) ? { mbeditorBackground: true } : {};
+    // opts.refresh bypasses the server's tree cache. The 10s poll must not set
+    // it — the cache is what keeps that poll cheap.
+    if (opts && opts.refresh) cfg.params = { refresh: 1 };
     return axios.get(window.mbeditorBasePath() + '/files', cfg).then(function(res) { return res.data; });
   }
 
@@ -222,10 +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 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 testTimeout = 180;
+  function setTestTimeout(seconds) { if (seconds > 0) testTimeout = seconds; }
+
   function runTests(path, line) {
     var payload = { path: path };
     if (line) payload.line = line;
-    return axios.post(window.mbeditorBasePath() + '/test', payload, { timeout: 120000 }).then(function(res) { return res.data; });
+    // 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: (testTimeout + 30) * 1000 }).then(function(res) { return res.data; });
   }
 
   function ping() {
@@ -305,6 +370,23 @@ var FileService = (function () {
     prefetchCache.set(path, entry);
   }
 
+  // Put content we already hold into the same cache a hover-prefetch fills, so
+  // the open that follows serves from memory instead of the network.
+  //
+  // Used after creating a file: we just wrote it and know exactly what is in
+  // it, yet opening it went straight back to the server to be told the same
+  // thing. This reuses the prefetch path rather than adding a second content
+  // cache, so the consume-once and TTL rules stay in one place.
+  function seedPrefetch(path, content) {
+    prefetchCache.set(path, {
+      // Never fetched, so there is nothing to abort — but cancelPrefetch calls
+      // abort() unconditionally, so the shape has to match.
+      controller: { abort: function () {} },
+      promise: Promise.resolve({ content: content, missing: false }),
+      resolvedAt: Date.now()
+    });
+  }
+
   // Returns a Promise for the cached result and removes the entry (consume-once),
   // or returns null if no prefetch is in-flight / completed for this path.
   // Settled entries older than PREFETCH_TTL_MS are treated as expired.
@@ -380,6 +462,15 @@ var FileService = (function () {
     }).then(function (res) { return res.data; });
   }
 
+  // Whole-workspace rubocop. mode 'autocorrect' runs `-a` and writes to disk.
+  // Generous timeout: a cold run over a large app is slow, and there is no
+  // progress stream to fall back on.
+  function runRubocop(mode) {
+    return axios.post(window.mbeditorBasePath() + '/rubocop',
+      { mode: mode || 'check' }, { timeout: 300000 }
+    ).then(function (res) { return res.data; });
+  }
+
   // Exceptions raised by the host app, newest first. The cable push is the
   // live path; this seeds the panel and covers hosts without ActionCable.
   function getExceptions() {
@@ -471,6 +562,7 @@ var FileService = (function () {
     getJsDefinition: getJsDefinition,
     getJsMembers: getJsMembers,
     prefetch: prefetch,
+    seedPrefetch: seedPrefetch,
     getPrefetched: getPrefetched,
     cancelPrefetch: cancelPrefetch,
     getModuleMembers: getModuleMembers,
@@ -483,6 +575,8 @@ var FileService = (function () {
     lspDiagnostics: lspDiagnostics,
     rubyRename: rubyRename,
     getModelGraph: getModelGraph,
+    runRubocop: runRubocop,
+    setTestTimeout: setTestTimeout,
     getExceptions: getExceptions,
     clearExceptions: clearExceptions,
     getRelatedFiles: getRelatedFiles,

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

@@ -1,7 +1,21 @@
 var GitService = (function () {
   function applyGitInfo(data) {
     var files = data.workingTree || data.files || [];
-    var current = EditorStore.getState().gitFiles;
+    var st = EditorStore.getState();
+    var current = st.gitFiles;
+
+    // /git_info runs on every window focus, and the payload is a fresh object
+    // every time — writing it unconditionally re-rendered the whole app for a
+    // repository that had not moved. Same trap, same fix as the file-tree poll
+    // (see _treeUpdater in MbeditorApp.js). The comparison has to be the whole
+    // payload, not the scalars: unpushedCommits and branchCommits move on their
+    // own (an amend leaves branch/ahead/behind untouched), and the panel reads
+    // all of them.
+    if (st.gitInfoError == null && JSON.stringify(data) === JSON.stringify(st.gitInfo)) {
+      clearHistoryCache();
+      return;
+    }
+
     var stateUpdate = {
       gitBranch: data.branch || "",
       gitInfo: data,
@@ -11,6 +25,10 @@ var GitService = (function () {
     if (gitSig(files) !== gitSig(current)) {
       stateUpdate.gitFiles = files;
     }
+    // A full git_info means the repository moved — commit, branch switch, or an
+    // external change. That is exactly when a file's last-commit answer can
+    // differ, so this is where the per-file history cache is dropped.
+    clearHistoryCache();
     EditorStore.setState(stateUpdate);
   }
 
@@ -30,6 +48,20 @@ var GitService = (function () {
       });
   }
 
+  // Collapses a run of working-tree changes into one /git_info fan-out once
+  // the run stops. A branch change is NOT routed through here — that is rare,
+  // user-visible, and escalates immediately.
+  var GIT_INFO_REFRESH_DEBOUNCE_MS = 1500;
+  var _infoRefreshTimer = null;
+
+  function _scheduleInfoRefresh() {
+    if (_infoRefreshTimer) clearTimeout(_infoRefreshTimer);
+    _infoRefreshTimer = setTimeout(function () {
+      _infoRefreshTimer = null;
+      fetchInfo();
+    }, GIT_INFO_REFRESH_DEBOUNCE_MS);
+  }
+
   // Cheap steady-state poll: hits /git_status (2 git subprocesses) and only
   // escalates to the expensive /git_info fan-out when something actually
   // changed — an external branch switch or a working-tree change. Rich fields
@@ -51,6 +83,18 @@ var GitService = (function () {
         var branchChanged = (data.branch || "") !== (st.gitBranch || "");
         var treeChanged = gitSig(files) !== gitSig(st.gitFiles || []);
 
+        // A checkout rewrites the working tree wholesale, and nothing else
+        // tells the editor: the files_changed push only ever announces
+        // mbeditor's own writes, and the 10s poll refreshes the tree's shape,
+        // not the contents behind open tabs. So every buffer stayed on the old
+        // branch's text until something happened to touch it. Announce it and
+        // let the app re-read what it is showing.
+        if (branchChanged && st.gitBranch) {
+          window.dispatchEvent(new CustomEvent('mbeditor:branch-changed', {
+            detail: { from: st.gitBranch, to: data.branch || "" }
+          }));
+        }
+
         // No full snapshot yet, or the branch changed under us (external
         // `git checkout`) — run the full fan-out.
         if (!prevInfo || !prevInfo.ok || branchChanged) return fetchInfo();
@@ -64,7 +108,17 @@ var GitService = (function () {
             gitInfo: Object.assign({}, prevInfo, { branch: data.branch || "", workingTree: files }),
             gitInfoError: null
           });
-          return fetchInfo();
+          // Trailing debounce, because this is the escalation that hurts.
+          // Saving a file changes the porcelain signature by definition, so
+          // saving a run of files fired the full fan-out — four-plus git
+          // subprocesses on the server, the most expensive request the editor
+          // makes — once per save, each one arriving while the previous was
+          // still running. The cheap fields above are what the badges and the
+          // file list actually read; the rich ones (ahead/behind, base branch,
+          // unpushed commits) are not worth a fan-out per keystroke-save and
+          // are perfectly happy to land once the burst is over.
+          _scheduleInfoRefresh();
+          return data;
         }
 
         return data;
@@ -118,16 +172,83 @@ var GitService = (function () {
   }
 
   // Per-line add/modify/delete ranges for one file, used to tint line numbers.
+  //
+  // Two different duplications get collapsed here, both measured:
+  //
+  //   - Concurrent calls share one flight. The tint effect re-runs as a freshly
+  //     opened tab's content version settles, so every file open fired two
+  //     identical `git diff` subprocesses about 8ms apart.
+  //   - A just-resolved result is reused for a moment afterwards. Creating a
+  //     file fetches once when the new tab mounts and again when the server's
+  //     broadcast for that same write arrives ~150ms later; both describe the
+  //     identical on-disk state.
+  //
+  // The reuse window is only safe because any local write drops the entry
+  // (invalidateLineDiff, called from noteLocalSave). That is what makes this
+  // exact rather than a guess: the window can only ever merge two fetches with
+  // no write between them, so a save always gets a fresh diff — which matters,
+  // because a save's broadcast is the *only* thing that refreshes the tint.
+  //
+  // ponytail: an external write landing within the window right after an
+  // unrelated fetch of the same file can still serve one stale tint; the 10s
+  // poll heals it. Thread the write's timestamp through the broadcast if that
+  // ever shows up in practice.
+  var LINE_DIFF_REUSE_MS = 400;
+  var _lineDiffFlights = {};
+
   function fetchLineDiff(path) {
-    return axios.get(window.mbeditorBasePath() + '/git/line_diff?file=' + encodeURIComponent(path)).then(function(res) {
-      return res.data;
-    });
+    var entry = _lineDiffFlights[path];
+    if (entry && (entry.resolvedAt === null || Date.now() - entry.resolvedAt < LINE_DIFF_REUSE_MS)) {
+      return entry.promise;
+    }
+
+    var self = { resolvedAt: null, promise: null };
+    var drop = function () { if (_lineDiffFlights[path] === self) delete _lineDiffFlights[path]; };
+    self.promise = axios.get(window.mbeditorBasePath() + '/git/line_diff?file=' + encodeURIComponent(path))
+      .then(function (res) { self.resolvedAt = Date.now(); return res.data; },
+            // A failure is never reused — drop it so the next call retries.
+            function (err) { drop(); throw err; });
+
+    _lineDiffFlights[path] = self;
+    return self.promise;
+  }
+
+  // Called whenever this client writes the file, so the next tint request goes
+  // back to git instead of reusing a pre-write answer.
+  function invalidateLineDiff(path) {
+    delete _lineDiffFlights[path];
   }
 
+  // Which commit last touched this file, for the status bar.
+  //
+  // Cached per path because the caller keys on the active tab id, so every tab
+  // activation re-ran `git log` for that file — including switching straight
+  // back to a tab you just left. The answer only moves when the repository
+  // does, and tab switching never refreshes git_info, so flicking between
+  // files is now free. The cached value is the promise itself, which makes
+  // concurrent callers share one flight as well.
+  //
+  // Dropped wholesale by clearHistoryCache() below, from applyGitInfo — a
+  // commit, a branch switch and an external change all produce a full git_info,
+  // so anything that can change the answer already clears this.
+  var _fileHistoryCache = {};
+
   function fetchFileHistory(path) {
-    return axios.get(window.mbeditorBasePath() + '/git/file_history?file=' + encodeURIComponent(path)).then(function(res) {
-      return res.data;
-    });
+    var hit = _fileHistoryCache[path];
+    if (hit) return hit;
+
+    var flight = axios.get(window.mbeditorBasePath() + '/git/file_history?file=' + encodeURIComponent(path))
+      .then(function (res) { return res.data; },
+            // A failure must not be cached, or one blip pins the error until
+            // the next git event.
+            function (err) { delete _fileHistoryCache[path]; throw err; });
+
+    _fileHistoryCache[path] = flight;
+    return flight;
+  }
+
+  function clearHistoryCache() {
+    _fileHistoryCache = {};
   }
 
   function fetchCommitGraph() {
@@ -149,6 +270,7 @@ var GitService = (function () {
     fetchDiff: fetchDiff,
     fetchBlame: fetchBlame,
     fetchLineDiff: fetchLineDiff,
+    invalidateLineDiff: invalidateLineDiff,
     fetchFileHistory: fetchFileHistory,
     fetchCommitGraph: fetchCommitGraph,
     fetchCommitDetail: fetchCommitDetail

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

@@ -25,10 +25,19 @@ var HistoryService = (function () {
     _bases[k] = baseContent;
   }
 
-  function resumeTracking(branch, filePath) {
+  // Reusing a cached model: the ops already recorded against this key still
+  // apply, so an existing base must not be replaced. But the key is per
+  // BRANCH, so switching branch (or clearing history) lands here with nothing
+  // recorded on either side, and a base-less first flush is a guaranteed
+  // "base required for initial history" 400. With no ops pending, the current
+  // content IS the base. The server ignores it once history exists.
+  function resumeTracking(branch, filePath, baseContent) {
     _tracking[filePath] = { branch: branch };
     var k = _key(branch, filePath);
     _pending[k] = _pending[k] || [];
+    if (!_bases.hasOwnProperty(k) && _pending[k].length === 0 && baseContent !== undefined) {
+      _bases[k] = baseContent;
+    }
   }
 
   function stopTracking(filePath) {
@@ -69,7 +78,7 @@ var HistoryService = (function () {
     _idleTimers[k] = setTimeout(function () { flush(rec.branch, filePath); }, IDLE_MS);
   }
 
-  function flush(branch, filePath) {
+  function flush(branch, filePath, keepalive) {
     var k = _key(branch, filePath);
     var ops = _pending[k];
     if (!ops || ops.length === 0) return;
@@ -83,6 +92,19 @@ var HistoryService = (function () {
       delete _bases[k];
     }
 
+    // Put the ops — and the base, which this attempt consumed — back so the
+    // next flush retries. fetch only rejects on a transport failure, so a
+    // rejected POST has to be requeued from the response as well: a 400 used
+    // to discard the base along with the ops, and every later flush for that
+    // file was then a fresh "base required for initial history" 400. One
+    // dropped request permanently disabled persistent undo for the file.
+    function requeue() {
+      _pending[k] = ops.concat(_pending[k] || []);
+      if (body.base !== undefined && !_bases.hasOwnProperty(k)) {
+        _bases[k] = body.base;
+      }
+    }
+
     try {
       fetch(window.mbeditorBasePath() + '/file_history', {
         method: 'POST',
@@ -90,47 +112,20 @@ var HistoryService = (function () {
           'Content-Type': 'application/json',
           'X-Mbeditor-Client': '1'
         },
+        keepalive: keepalive === true,
         body: JSON.stringify(body)
-      }).catch(function () {
-        // On failure, put ops back so next flush retries
-        var existing = _pending[k] || [];
-        _pending[k] = ops.concat(existing);
-        if (body.base !== undefined && !_bases.hasOwnProperty(k)) {
-          _bases[k] = body.base;
-        }
-      });
-    } catch (e) {}
+      }).then(function (res) {
+        if (!res.ok) requeue();
+      })["catch"](requeue);
+    } catch (e) {
+      requeue();
+    }
   }
 
   function flushAll(options) {
-    var useKeepalive = options && options.keepalive;
+    var keepalive = !!(options && options.keepalive);
     Object.keys(_tracking).forEach(function (filePath) {
-      var rec = _tracking[filePath];
-      var k = _key(rec.branch, filePath);
-      var ops = _pending[k];
-      if (!ops || ops.length === 0) return;
-      var remaining = ops.slice();
-      _pending[k] = [];
-      clearTimeout(_idleTimers[k]);
-      delete _idleTimers[k];
-
-      var body = { branch: rec.branch, path: filePath, ops: remaining };
-      if (_bases.hasOwnProperty(k)) {
-        body.base = _bases[k];
-        delete _bases[k];
-      }
-
-      try {
-        fetch(window.mbeditorBasePath() + '/file_history', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'X-Mbeditor-Client': '1'
-          },
-          keepalive: useKeepalive === true,
-          body: JSON.stringify(body)
-        });
-      } catch (e) {}
+      flush(_tracking[filePath].branch, filePath, keepalive);
     });
   }
 

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

@@ -59,6 +59,10 @@ var LogService = (function () {
     _offset = null;
     _lines = [];
     _fetchOnce().then(function () {
+      // A stop() while that first fetch was in flight already ran the teardown;
+      // starting the transport now would leave the poll interval running (and
+      // the server tailing) with nothing to stop it.
+      if (!_active) return;
       if (window.WebSocketService && WebSocketService.isConnected()) {
         _usingWs = true;
         WebSocketService.onLogLines(_onWsLog);