mbeditor 0.11.0 → 0.12.0

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

@@ -0,0 +1,146 @@
+'use strict';
+
+// Turns a drop's DataTransfer into a flat list of { file, relativePath }
+// entries and packs them into the multipart body the /import endpoint wants.
+//
+// Directory drops are walked with webkitGetAsEntry — non-standard, but the
+// only way any browser exposes a dropped folder. Where it is missing we fall
+// back to dataTransfer.files, which is flat: files import, folders vanish.
+var FileImport = (function () {
+  // Mirrors EditorsController::IMPORT_MAX_FILES. Trimming client-side means a
+  // stray node_modules drop reports a clear message instead of a 422 — and
+  // keeps the batch under Rack's 128-file-part multipart limit, which would
+  // otherwise reject the request as a 500 before the server guard can run.
+  var MAX_ENTRIES = 100;
+
+  function hasExternalFiles(dataTransfer) {
+    if (!dataTransfer || !dataTransfer.types) return false;
+    return Array.prototype.indexOf.call(dataTransfer.types, 'Files') !== -1;
+  }
+
+  // MUST be called synchronously from the drop handler: DataTransferItem
+  // objects are neutered the moment the handler returns, so every entry is
+  // pulled off the item list up front and only then walked asynchronously.
+  function collectEntries(dataTransfer) {
+    var items = dataTransfer.items;
+    var roots = [];
+    var supportsEntries = typeof DataTransferItem !== 'undefined' &&
+      DataTransferItem.prototype.webkitGetAsEntry;
+
+    if (items && items.length && supportsEntries) {
+      for (var i = 0; i < items.length; i++) {
+        if (items[i].kind !== 'file') continue;
+        var entry = items[i].webkitGetAsEntry();
+        if (entry) roots.push(entry);
+      }
+    }
+
+    if (roots.length === 0) {
+      var flat = [];
+      var files = dataTransfer.files || [];
+      for (var j = 0; j < files.length; j++) {
+        flat.push({ file: files[j], relativePath: files[j].name });
+      }
+      return Promise.resolve({
+        entries: flat.slice(0, MAX_ENTRIES),
+        truncated: flat.length > MAX_ENTRIES,
+        foldersSkipped: !!(items && items.length > flat.length)
+      });
+    }
+
+    var collected = [];
+    return walkAll(roots, collected).then(function () {
+      return {
+        entries: collected.slice(0, MAX_ENTRIES),
+        truncated: collected.length > MAX_ENTRIES,
+        foldersSkipped: false
+      };
+    });
+  }
+
+  function walkAll(entries, out) {
+    return entries.reduce(function (chain, entry) {
+      return chain.then(function () { return walk(entry, out); });
+    }, Promise.resolve());
+  }
+
+  function walk(entry, out) {
+    if (entry.isFile) {
+      return new Promise(function (resolve) {
+        entry.file(function (file) {
+          out.push({ file: file, relativePath: stripLeadingSlash(entry.fullPath) });
+          resolve();
+        }, function () { resolve(); });
+      });
+    }
+    if (!entry.isDirectory) return Promise.resolve();
+
+    var reader = entry.createReader();
+    // readEntries hands back at most ~100 children per call and signals the
+    // end of the directory with an empty batch, so it has to be called until
+    // it runs dry rather than once.
+    var readBatch = function () {
+      return new Promise(function (resolve) {
+        reader.readEntries(function (batch) { resolve(batch); }, function () { resolve([]); });
+      }).then(function (batch) {
+        if (!batch || batch.length === 0) return null;
+        return walkAll(batch, out).then(readBatch);
+      });
+    };
+    return readBatch();
+  }
+
+  function stripLeadingSlash(p) {
+    return String(p || '').replace(/^\/+/, '');
+  }
+
+  // '' as the folder means the workspace root.
+  function joinPath(folder, relativePath) {
+    var rel = stripLeadingSlash(relativePath);
+    if (!folder) return rel;
+    return folder.replace(/\/+$/, '') + '/' + rel;
+  }
+
+  function buildFormData(entries, targetFolderPath, onConflict) {
+    var fd = new FormData();
+    fd.append('on_conflict', onConflict);
+    entries.forEach(function (e) {
+      fd.append('files[]', e.file, e.file.name);
+      fd.append('paths[]', joinPath(targetFolderPath, e.relativePath));
+    });
+    return fd;
+  }
+
+  // Match conflict occurrences from the end of the original entry list. If
+  // two dropped files map to one previously-free path, pass one imports the
+  // first and reports only the later occurrence as conflicting; retrying every
+  // entry with that path would duplicate the already-imported file.
+  function conflictedEntries(entries, targetFolderPath, conflicts) {
+    var remaining = {};
+    (conflicts || []).forEach(function(c) {
+      var key = '$' + c.path;
+      remaining[key] = (remaining[key] || 0) + 1;
+    });
+
+    var retry = [];
+    for (var i = entries.length - 1; i >= 0; i--) {
+      var targetKey = '$' + joinPath(targetFolderPath, entries[i].relativePath);
+      if (!remaining[targetKey]) continue;
+      retry.unshift(entries[i]);
+      remaining[targetKey] -= 1;
+    }
+    return retry;
+  }
+
+  return {
+    MAX_ENTRIES: MAX_ENTRIES,
+    hasExternalFiles: hasExternalFiles,
+    collectEntries: collectEntries,
+    joinPath: joinPath,
+    buildFormData: buildFormData,
+    conflictedEntries: conflictedEntries
+  };
+})();
+
+// Expose globally for sprockets require
+window.FileImport = FileImport;

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

@@ -70,6 +70,15 @@ var FileService = (function () {
     return axios.post(window.mbeditorBasePath() + '/create_file', { path: path, code: code || '' }).then(function(res) { return res.data; });
   }
 
+  // Multipart import of files dragged in from outside the browser. The
+  // default 30 s axios timeout is too tight for a large drop on a slow disk,
+  // so this one call gets a longer leash.
+  function importFiles(formData) {
+    return axios.post(window.mbeditorBasePath() + '/import', formData, {
+      timeout: 120000
+    }).then(function (res) { return res.data; });
+  }
+
   function createDir(path) {
     return axios.post(window.mbeditorBasePath() + '/create_dir', { path: path }).then(function(res) { return res.data; });
   }
@@ -224,15 +233,50 @@ var FileService = (function () {
   // | 'completion'; line/character are Monaco 1-based. The server answers in
   // provider-ready shapes, or { fallback: true } when the LSP can't answer in
   // time (caller then uses the legacy grep/Ripper path).
-  function rubyLspRequest(lspMethod, path, content, line, character, extraOptions) {
+  // extraBody carries per-method request params (e.g. formatting's tab_size);
+  // extraOptions is axios config (e.g. a longer timeout).
+  function rubyLspRequest(lspMethod, path, content, line, character, extraOptions, extraBody) {
     var config = Object.assign({ timeout: 6000 }, extraOptions || {});
-    return axios.post(window.mbeditorBasePath() + '/ruby_lsp', {
+    var body = Object.assign({
       lsp_method: lspMethod,
       path: path,
       content: content,
       line: line,
       character: character
-    }, config).then(function(res) { return res.data; });
+    }, extraBody || {});
+    return axios.post(window.mbeditorBasePath() + '/ruby_lsp', body, config)
+      .then(function(res) { return res.data; });
+  }
+
+  // ActiveRecord models and their associations. Generating this eager-loads the
+  // host app, so the timeout is generous and it is only requested on demand.
+  function getModelGraph(force) {
+    return axios.get(window.mbeditorBasePath() + '/model_graph', {
+      params: force ? { refresh: 1 } : {},
+      timeout: 60000
+    }).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() {
+    return axios.get(window.mbeditorBasePath() + '/exceptions')
+      .then(function (res) { return res.data; });
+  }
+
+  function clearExceptions() {
+    return axios["delete"](window.mbeditorBasePath() + '/exceptions')
+      .then(function (res) { return res.data; });
+  }
+
+  // Rename a Ruby constant across the workspace. openPaths lists every file
+  // with a live editor model: the server returns their edits for Monaco to
+  // apply (undoable, marks the tab dirty) and writes the rest to disk itself.
+  function rubyRename(path, content, line, character, newName, openPaths) {
+    return axios.post(window.mbeditorBasePath() + '/ruby_rename', {
+      path: path, content: content, line: line, character: character,
+      new_name: newName, open_paths: openPaths || []
+    }, { timeout: 35000 }).then(function (res) { return res.data; });
   }
 
   // Whole-document Ruby diagnostics from ruby-lsp (RuboCop offenses + Prism
@@ -283,6 +327,7 @@ var FileService = (function () {
     getFileChunk: getFileChunk,
     saveFile: saveFile,
     createFile: createFile,
+    importFiles: importFiles,
     createDir: createDir,
     renamePath: renamePath,
     deletePath: deletePath,
@@ -310,6 +355,10 @@ var FileService = (function () {
     getJsProgramFile: getJsProgramFile,
     rubyLspRequest: rubyLspRequest,
     lspDiagnostics: lspDiagnostics,
+    rubyRename: rubyRename,
+    getModelGraph: getModelGraph,
+    getExceptions: getExceptions,
+    clearExceptions: clearExceptions,
     getRelatedFiles: getRelatedFiles,
     getModelSchema: getModelSchema,
     getChangelog: getChangelog

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

@@ -61,6 +61,10 @@ var TabManager = (function () {
         entry.model.dispose();
       }
       delete window.__mbeditorModels[candidate];
+      // The evicted file is not open in any pane — tear down its collaboration room.
+      if (typeof CollaborationService !== 'undefined') {
+        CollaborationService.leaveRoom(candidate);
+      }
     }
   }
 
@@ -141,7 +145,32 @@ var TabManager = (function () {
     });
   }
 
+  // Single slot holding "where the cursor was before the last jump".
+  // PageUp/PageDown swap the cursor between this slot and its current spot.
+  // ponytail: two-position cycle, upgrade to a real back/forward stack if asked
+  var _jumpOrigin = null;
+
+  function _snapshotPosition() {
+    var editor = window.__mbeditorActiveEditor;
+    var pos = editor && editor.getPosition ? editor.getPosition() : null;
+    if (!pos) return null;
+    var state = EditorStore.getState();
+    var pane = state.panes.find(function(p) { return p.id === state.focusedPaneId; });
+    var tab = pane && pane.tabs.find(function(t) { return t.id === pane.activeTabId; });
+    if (!tab || !tab.path) return null;
+    return { path: tab.path, name: tab.name, line: pos.lineNumber, col: pos.column };
+  }
+
+  function toggleJumpOrigin() {
+    var target = _jumpOrigin;
+    if (!target) return;
+    // openTab re-snapshots the current position into _jumpOrigin below,
+    // which is exactly the swap we want.
+    openTab(target.path, target.name, target.line, null, false, target.col);
+  }
+
   function openTab(path, name, line, forcePaneId, isSoftOpen, col) {
+    if (line) _jumpOrigin = _snapshotPosition() || _jumpOrigin;
     var state = EditorStore.getState();
     var paneId = forcePaneId || state.focusedPaneId;
     var pane = state.panes.find(function(p) { return p.id === paneId; });
@@ -360,8 +389,23 @@ var TabManager = (function () {
     axios.get(window.mbeditorBasePath() + '/git/combined_diff', { params: { scope: scope || 'local' } })
       .then(function(res) {
         var data = res.data;
+        var text = typeof data === 'string' ? data : (data && data.diff) || '';
+        // The server reports what it compared against, and says so when it
+        // could not work out a base at all — otherwise an empty diff looks
+        // identical to "no changes" and hides the real problem.
+        var headers = res.headers || {};
+        var baseRef = headers['x-mbeditor-diff-base'];
+        var diffError = headers['x-mbeditor-diff-error'];
+
+        if (diffError) {
+          text = '# ' + diffError + '\n';
+        } else if (baseRef && text.trim() === '') {
+          text = '# No changes compared to ' + baseRef + '.\n';
+        }
+
         _updateTab(paneId, tabId, {
-          combinedDiffText: typeof data === 'string' ? data : (data && data.diff) || '',
+          combinedDiffText: text,
+          combinedDiffBase: baseRef || null,
           combinedDiffLoaded: true
         });
       })
@@ -434,6 +478,10 @@ var TabManager = (function () {
           _entry.model.dispose();
         }
         delete window.__mbeditorModels[path];
+        // File is no longer open in any pane — tear down its collaboration room.
+        if (typeof CollaborationService !== 'undefined') {
+          CollaborationService.leaveRoom(path);
+        }
       }
     }
   }
@@ -617,6 +665,7 @@ var TabManager = (function () {
     reorderTabInPane: reorderTabInPane,
     moveTabToPane: moveTabToPane,
     clearGotoLine: clearGotoLine,
+    toggleJumpOrigin: toggleJumpOrigin,
     closeAllTabsInPane: closeAllTabsInPane,
     closeOtherTabsInPane: closeOtherTabsInPane,
     closeSavedTabsInPane: closeSavedTabsInPane,

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

@@ -11,6 +11,8 @@ var WebSocketService = (function () {
   var _subscription = null;
   var _connected = false;
   var _filesChangedCallbacks = [];
+  var _fileSavedCallbacks = [];
+  var _presenceCallbacks = [];
   var _logLinesCallbacks = [];
   var _serverSupportsWs = false;
   var _reconnectTimer = null;
@@ -117,8 +119,14 @@ var WebSocketService = (function () {
             if (!data) return;
             if (data.type === 'files_changed') {
               _emitFilesChanged(data);
+            } else if (data.type === 'file_saved') {
+              _emitFileSaved(data);
+            } else if (data.type === 'presence') {
+              _emitPresence(data);
             } else if (data.type === 'log') {
               _emitLogLines(data);
+            } else if (data.type === 'exception') {
+              _emitException(data);
             }
           }
         }
@@ -136,12 +144,33 @@ var WebSocketService = (function () {
     });
   }
 
+  function _emitFileSaved(data) {
+    _fileSavedCallbacks.forEach(function (fn) {
+      try { fn(data); } catch (e) { /* ignore */ }
+    });
+  }
+
+  function _emitPresence(data) {
+    _presenceCallbacks.forEach(function (fn) {
+      try { fn(data); } catch (e) { /* ignore */ }
+    });
+  }
+
   function _emitLogLines(data) {
     _logLinesCallbacks.forEach(function (fn) {
       try { fn(data); } catch (e) { /* ignore */ }
     });
   }
 
+  // Host-app exceptions go out as a DOM event rather than a callback list:
+  // the Problems panel mounts and unmounts, so it subscribes and unsubscribes
+  // with its own lifecycle rather than registering here at boot.
+  function _emitException(data) {
+    try {
+      window.dispatchEvent(new CustomEvent('mbeditor:exception', { detail: data }));
+    } catch (e) { /* CustomEvent unavailable; the panel still polls on open */ }
+  }
+
   // ---------------------------------------------------------------------------
   // Public API
   // ---------------------------------------------------------------------------
@@ -172,6 +201,38 @@ var WebSocketService = (function () {
     return _connected;
   }
 
+  // Returns true when ActionCable is loaded and the server advertised cable
+  // support. Collaboration uses this as its up-front "is the feature available?"
+  // gate, independent of whether the EditorChannel handshake has completed yet.
+  function isCableAvailable() {
+    return _serverSupportsWs && _isActionCableAvailable();
+  }
+
+  // Open a CollaborationChannel subscription for one file on the SHARED consumer
+  // (the same connection the EditorChannel uses).  Returns the subscription, or
+  // null when cable is unavailable so callers can stay in single-user mode.
+  // handlers: { connected, received, rejected, disconnected } — all optional.
+  function subscribeCollaboration(path, handlers) {
+    if (!isCableAvailable()) return null;
+    handlers = handlers || {};
+    try {
+      if (!_consumer) {
+        _consumer = _getConsumer();
+      }
+      return _consumer.subscriptions.create(
+        { channel: 'Mbeditor::CollaborationChannel', path: path },
+        {
+          connected: function () { if (handlers.connected) handlers.connected(); },
+          disconnected: function () { if (handlers.disconnected) handlers.disconnected(); },
+          rejected: function () { if (handlers.rejected) handlers.rejected(); },
+          received: function (data) { if (handlers.received) handlers.received(data); }
+        }
+      );
+    } catch (e) {
+      return null;
+    }
+  }
+
   // Register a callback to be invoked when the server broadcasts files_changed.
   function onFilesChanged(fn) {
     _filesChangedCallbacks.push(fn);
@@ -182,6 +243,28 @@ var WebSocketService = (function () {
     _filesChangedCallbacks = _filesChangedCallbacks.filter(function (f) { return f !== fn; });
   }
 
+  // Register a callback to be invoked when a peer saves a file (file_saved).
+  // The callback receives the broadcast data, including the relative `path`.
+  function onFileSaved(fn) {
+    _fileSavedCallbacks.push(fn);
+  }
+
+  // Remove a previously registered file_saved callback.
+  function offFileSaved(fn) {
+    _fileSavedCallbacks = _fileSavedCallbacks.filter(function (f) { return f !== fn; });
+  }
+
+  // Register a callback for presence heartbeats/leaves relayed on the global
+  // stream. The callback receives {type:'presence', status, client_id, ...}.
+  function onPresence(fn) {
+    _presenceCallbacks.push(fn);
+  }
+
+  // Remove a previously registered presence callback.
+  function offPresence(fn) {
+    _presenceCallbacks = _presenceCallbacks.filter(function (f) { return f !== fn; });
+  }
+
   // Register a callback invoked when the server transmits a { type: 'log' } message.
   function onLogLines(fn) {
     _logLinesCallbacks.push(fn);
@@ -207,9 +290,15 @@ var WebSocketService = (function () {
     connect: connect,
     disconnect: disconnect,
     isConnected: isConnected,
+    isCableAvailable: isCableAvailable,
+    subscribeCollaboration: subscribeCollaboration,
     perform: perform,
     onFilesChanged: onFilesChanged,
     offFilesChanged: offFilesChanged,
+    onFileSaved: onFileSaved,
+    offFileSaved: offFileSaved,
+    onPresence: onPresence,
+    offPresence: offPresence,
     onLogLines: onLogLines,
     offLogLines: offLogLines
   };