mbeditor 0.12.2 → 0.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2d9c1ba81f945f5ce0772455f51e66a110fa43a1e24f62c96e6859312c4a968
-  data.tar.gz: d01eb3a6edd6e221e92c25e093c7c5944b32c50dafad6a4cacfa953e5c0b1925
+  metadata.gz: 88d963e43c97cf6974b3e38c079ffd2dba642dc1c13a68237f1a3a4f7c21e9a0
+  data.tar.gz: 9e32a366d6ea7ce5014fff94ee89adba7f6909d09aa29f6404142b4155688a3a
 SHA512:
-  metadata.gz: f8c189fa9f7215d5a376ab321a10186645c6671a2c1de874c3f3b254e3ebebb20a2c102e0c5357fb0ee0183eb0c634d2f26c7f7860901cec8e941f56ca26bd75
-  data.tar.gz: d0f8bdb6abe76b88e8438c0f31e78055d49fe09dfb3c88df1031312c33985b8ad2906f72482cc32a7c986a4019dee19226e42c96fa6d99b52f1da1cdb4faa790
+  metadata.gz: 100805339d3956837f0ec5349de86b5bcf4315ef5dd261e76b80c0acb589cd9036264b70bb65677be3d27be9575007daee02e08c1cbad86ac3136bd331312a6b
+  data.tar.gz: d1d0681c8962251ceb0d9f18db0937e20f3c1ae1e2d30754a08a88ee10a47b6a6492641de84b9e83c0b2ab81963e79d1f3d86bb61a985bfa7b4a5eb579d0548d

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.3] - 2026-08-03
+
+### Added
+- **`config.cable_authenticate_with`** — authentication for the collaboration
+  WebSocket, falling back to `authenticate_with` when unset.
+- **A "Pairing off" chip and diagnostics panel.** When collaboration cannot
+  work, the editor now says so and lists every condition it depends on — the
+  vendored libraries, Action Cable's JavaScript, whether the server advertises
+  it, whether the socket actually connected, and whether anyone else is here —
+  with the fix written beside each failure. Nothing is shown when everything is
+  healthy and you are simply alone.
+
+### Fixed
+- **A WebSocket subscribe runs no controller, and this made pairing silently
+  impossible for most authenticated apps.** `authenticate_with` is evaluated on
+  the cable against a probe exposing `session`, `cookies`, `request` and
+  `params` — so a hook reading `Current.user`, calling `UserSession.find`, or
+  using a memoised `current_user` gets `nil` or a `NameError`, denies, and the
+  socket is rejected. The hook keeps working perfectly over HTTP, so nothing
+  looks wrong; collaboration simply never connects.
+
+  Rejections are now logged as `[mbeditor] WebSocket subscription rejected: …`
+  naming the cause, `cable_authenticate_with` provides an escape hatch when one
+  proc cannot serve both contexts, and the README says this plainly instead of
+  noting that request-scoped state "may be narrower". The README's own example
+  used `UserSession.find`, which is exactly the pattern that cannot work.
+
 ## [0.12.2] - 2026-08-03
 
 ### Added

data/README.md

@@ -67,8 +67,12 @@ Mbeditor.configure do |config|
   config.excluded_paths = %w[.git tmp log node_modules .bundle coverage vendor/bundle]
   config.rubocop_command = "bundle exec rubocop"
 
-  # Optional authentication (runs as a before_action in the engine controllers)
-  # config.authenticate_with = proc { redirect_to login_path unless UserSession.find }
+  # Optional authentication (runs as a before_action in the engine controllers,
+  # and on the collaboration WebSocket subscribe). Resolve the user from
+  # `session` — a WebSocket subscribe runs no controller, so Current.user,
+  # UserSession.find and a memoised current_user are all unavailable there.
+  # config.authenticate_with = proc { redirect_to login_path unless User.find_by(id: session[:user_id]) }
+  # config.cable_authenticate_with = proc { ... }  # when one proc cannot serve both
 
   # Optional test runner (Minitest or RSpec)
   # config.test_framework = :minitest   # :minitest or :rspec — auto-detected when nil
@@ -123,6 +127,7 @@ end
 | Option | Default | Description |
 |--------|---------|-------------|
 | `authenticate_with` | `nil` | Proc run as a `before_action` in all engine controllers. Executed via `instance_exec` inside the controller, so it has access to `session`, `cookies`, `redirect_to`, and auth-library class methods (e.g. Authlogic's `UserSession.find`) — but not helper methods from the host's `ApplicationController`. The same hook is also evaluated when the collaboration / editor **WebSocket** subscribes (see [Collaborative pairing](#collaborative-pairing-optional)); if it halts or raises, that subscription is rejected (fail-closed). Over the cable the proc runs against a request-derived probe, so request-scoped state may be narrower than over HTTP. |
+| `cable_authenticate_with` | `nil` | Authentication for the collaboration WebSocket; `nil` falls back to `authenticate_with`. Set this when the HTTP hook cannot work on the cable — a WebSocket subscribe runs no controller, so `Current.*`, an Authlogic `UserSession` and a memoised `current_user` are `nil` or raise, and the hook then denies the socket while working perfectly over HTTP. See [Collaborative pairing](#collaborative-pairing-optional). |
 | `authentication_cache_ttl` | `0` | Seconds to cache the auth result in the session (`0` = no caching). Set e.g. `300` to avoid calling `authenticate_with` on every request when the proc is expensive. Trade-off: after host logout, mbeditor stays accessible for up to TTL seconds. |
 
 ### Test runner
@@ -335,20 +340,45 @@ should be able to reach the port.
 
 **2. Set an authentication hook — it runs on the WebSocket handshake.**
 Configure `authenticate_with` (see the [Authentication](#authentication) options).
-The same hook that gates the HTTP editor is now also evaluated when the collaboration /
+The same hook that gates the HTTP editor is also evaluated when the collaboration /
 editor WebSocket subscribes: if it halts (e.g. `redirect_to`/`render`/`head`) — or raises —
 the socket subscription is **rejected (fail-closed)**, so pairing cannot bypass your auth.
 
+> **A WebSocket subscribe runs no controller.** This is the single most common reason
+> pairing appears to do nothing. Anything a `before_action` populates is unavailable on
+> the cable: `Current.user` (and any other `ActiveSupport::CurrentAttributes`) is `nil`,
+> `UserSession.find` raises because Authlogic's controller adapter was never activated,
+> and a memoised `current_user` is undefined. The hook then denies — correctly, given it
+> was handed nobody — and the socket is rejected. It works perfectly over HTTP the whole
+> time, so nothing looks wrong until you notice collaboration never connects.
+
+The hook is evaluated against a probe exposing `session`, `cookies`, `request`, `params`
+and the halt methods. Resolve the user from `session` so the same hook works in both
+contexts:
+
+```ruby
+Mbeditor.configure do |c|
+  c.authenticate_with = proc do
+    user = Current.user || User.find_by(id: session[:user_credentials_id])
+    head :forbidden unless user&.super_admin_access?
+  end
+end
+```
+
+When one proc genuinely cannot serve both, give the cable its own:
+
 ```ruby
 Mbeditor.configure do |c|
-  # Runs as a controller before_action AND on the cable subscribe.
-  c.authenticate_with = proc { head :forbidden unless UserSession.find }
+  c.authenticate_with       = proc { head :forbidden unless Current.user&.super_admin_access? }
+  c.cable_authenticate_with = proc do
+    head :forbidden unless User.find_by(id: session[:user_credentials_id])&.super_admin_access?
+  end
 end
 ```
 
-Because the cable mount can bypass parts of the host middleware stack, a hook that leans on
-request-scoped state (full `session`, encrypted `cookies`) may see less over the WebSocket
-than it does over HTTP. For defence in depth, also authenticate at your host app's
+Every rejection is logged as `[mbeditor] WebSocket subscription rejected: …` with the
+reason, so a denial is visible rather than silent. The editor also shows a **Pairing off**
+chip when collaboration cannot work, listing each failing condition. For defence in depth, also authenticate at your host app's
 `ApplicationCable::Connection` (the standard `identified_by` / `reject_unauthorized_connection`
 pattern) — mbeditor's hook is an additional gate, not a replacement for securing the cable
 connection itself.

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

@@ -120,6 +120,67 @@ var CollaborationService = (function () {
     });
   }
 
+  // Every condition collaboration depends on, reported separately.
+  //
+  // isAvailable() collapses five things into one boolean, which is useless when
+  // pairing does not work: "false" could be a missing vendored library, a cable
+  // the server never advertised, a rejected handshake, or simply nobody else
+  // being here. Someone debugging this on another machine cannot paste a console
+  // snippet back, so the editor has to be able to say which.
+  function diagnostics() {
+    var cableStatus = (typeof WebSocketService !== 'undefined' &&
+                       typeof WebSocketService.cableStatus === 'function')
+      ? WebSocketService.cableStatus() : 'unknown';
+
+    var checks = [
+      {
+        key: 'libraries',
+        label: 'Collaboration libraries loaded',
+        ok: typeof window.Y !== 'undefined' && typeof window.MonacoBinding !== 'undefined',
+        detail: 'vendor/assets/javascripts/yjs-collab.js is served by the asset pipeline. ' +
+                'If this fails, the host app is not serving it — try rails assets:clobber, ' +
+                'or check config.assets.precompile.'
+      },
+      {
+        key: 'actioncable',
+        label: 'Action Cable JavaScript present',
+        ok: typeof window.ActionCable !== 'undefined',
+        detail: 'The host app must make actioncable.js available to the page.'
+      },
+      {
+        key: 'advertised',
+        label: 'Server advertises Action Cable',
+        ok: typeof WebSocketService !== 'undefined' && WebSocketService.isCableAvailable(),
+        detail: 'Action Cable must be enabled and mounted in the host app routes.'
+      },
+      {
+        key: 'connected',
+        label: 'WebSocket connected',
+        ok: cableStatus === 'connected',
+        detail: cableStatus === 'rejected'
+          ? 'The server rejected the subscription. Usually action_cable.allowed_request_origins ' +
+            'not listing the origin you are reaching the editor through, or an authenticate_with ' +
+            'hook halting on the cable (it fails closed). Look for "Request origin not allowed" in the log.'
+          : 'Status: ' + cableStatus + '.'
+      },
+      {
+        key: 'peers',
+        label: 'Another participant connected',
+        ok: _peerPresent,
+        detail: 'Presence is held per web process. If two people are on different Puma workers ' +
+                'they never see each other — run a single worker (WEB_CONCURRENCY=0) while pairing.'
+      }
+    ];
+
+    return {
+      ok: checks.every(function (c) { return c.ok; }),
+      cableStatus: cableStatus,
+      checks: checks,
+      // The first failing check is the one worth acting on; the rest follow from it.
+      firstProblem: checks.filter(function (c) { return !c.ok; })[0] || null
+    };
+  }
+
   // Subscribe to availability transitions. Returns an unsubscribe function.
   function onAvailabilityChange(fn) {
     _availabilityListeners.push(fn);
@@ -674,6 +735,7 @@ var CollaborationService = (function () {
   return {
     isAvailable: isAvailable,
     setPeerPresent: setPeerPresent,
+    diagnostics: diagnostics,
     onAvailabilityChange: onAvailabilityChange,
     isEnabledFor: isEnabledFor,
     ensureRoom: ensureRoom,

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

@@ -2450,6 +2450,30 @@ var MbeditorApp = function MbeditorApp() {
   // external-change detection for solo users. The service is told about the roster
   // from the presence handler above, not from an effect here, so it hears about
   // every message rather than only about a change in the participant count.
+  var _collabDiag = useState(false);
+  var collabDiagOpen = _collabDiag[0], setCollabDiagOpen = _collabDiag[1];
+  var _collabTrouble = useState(null);
+  var collabTrouble = _collabTrouble[0], setCollabTrouble = _collabTrouble[1];
+
+  // Re-checked on a slow interval because the failures worth reporting — a
+  // rejected handshake, a dropped socket — happen asynchronously and nothing
+  // else would notice. Only the first failing check's key is stored, so an
+  // unchanged state is an identical string and React bails rather than
+  // re-rendering the app every tick.
+  useEffect(function () {
+    function check() {
+      if (typeof CollaborationService === 'undefined' ||
+          typeof CollaborationService.diagnostics !== 'function') return;
+      var d = CollaborationService.diagnostics();
+      // "Nobody else is here" is not a fault; everything else is.
+      var problem = d.firstProblem && d.firstProblem.key !== 'peers' ? d.firstProblem.key : null;
+      setCollabTrouble(function (prev) { return prev === problem ? prev : problem; });
+    }
+    check();
+    var id = setInterval(check, 10000);
+    return function () { clearInterval(id); };
+  }, []);
+
   var collabPeerIds = Object.keys(collabRoster);
 
   // A labelled peer chip costs ~110px (name + filename), and the titlebar button
@@ -4217,6 +4241,28 @@ var MbeditorApp = function MbeditorApp() {
             !toolbarIconOnly && " Git"
           )
         ),
+        // Collaboration trouble chip. Deliberately not shown when everything is
+        // healthy and you are simply alone — that was the whole point of hiding
+        // the solo chip. It appears only when a condition pairing needs has
+        // actually failed, so silence means "nobody here" and never "quietly
+        // broken", which is exactly the ambiguity that made a real pairing
+        // failure impossible to diagnose from the other machine.
+        collabTrouble && React.createElement(
+          React.Fragment,
+          null,
+          React.createElement("div", { className: "statusbar-sep" }),
+          React.createElement(
+            "button",
+            {
+              type: "button",
+              className: "statusbar-btn mbeditor-collab-trouble",
+              title: "Pairing is not available — click for details",
+              onClick: function () { setCollabDiagOpen(true); }
+            },
+            React.createElement("i", { className: "fas fa-user-slash" }),
+            !toolbarIconOnly && " Pairing off"
+          )
+        ),
         // Your own chip appears only once someone else is actually connected.
         // Alone it told you nothing — Action Cable is up in any normal dev setup,
         // so it sat in the toolbar permanently announcing a session of one. While
@@ -4358,6 +4404,49 @@ var MbeditorApp = function MbeditorApp() {
         )
       );
     })(),
+    // The diagnostics panel. Every condition listed with its own state, because
+    // the person who needs this is usually on the other machine and cannot paste
+    // a console snippet back.
+    collabDiagOpen && (function () {
+      var d = CollaborationService.diagnostics();
+      return React.createElement(
+        'div',
+        { className: 'mbeditor-modal-backdrop', onClick: function () { setCollabDiagOpen(false); } },
+        React.createElement(
+          'div',
+          { className: 'mbeditor-collab-diag', onClick: function (e) { e.stopPropagation(); } },
+          React.createElement('div', { className: 'mbeditor-collab-diag-title' }, 'Pair programming status'),
+          React.createElement(
+            'ul',
+            { className: 'mbeditor-collab-diag-list' },
+            d.checks.map(function (c) {
+              return React.createElement(
+                'li',
+                { key: c.key, className: 'mbeditor-collab-diag-row' + (c.ok ? '' : ' is-bad') },
+                React.createElement('i', { className: c.ok ? 'fas fa-check' : 'fas fa-times' }),
+                React.createElement(
+                  'div',
+                  null,
+                  React.createElement('div', { className: 'mbeditor-collab-diag-label' }, c.label),
+                  !c.ok && React.createElement('div', { className: 'mbeditor-collab-diag-detail' }, c.detail)
+                )
+              );
+            })
+          ),
+          React.createElement(
+            'div',
+            { className: 'mbeditor-collab-diag-foot' },
+            d.ok
+              ? 'Pairing is working.'
+              : 'The first failing item above is the one to fix; the rest follow from it.'
+          ),
+          React.createElement('button', {
+            type: 'button', className: 'ide-model-graph-btn',
+            onClick: function () { setCollabDiagOpen(false); }
+          }, 'Close')
+        )
+      );
+    })(),
     showHelp && React.createElement(ShortcutHelp, { onClose: function () { return setShowHelp(false); } }),
     React.createElement(
       "div",

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

@@ -10,6 +10,11 @@ var WebSocketService = (function () {
   var _consumer = null;
   var _subscription = null;
   var _connected = false;
+  // Why collaboration is or is not working, so the editor can say so instead of
+  // failing silently. A rejected subscription used to just schedule a reconnect
+  // and tell nobody, which made a blocked cable indistinguishable from an empty
+  // room.
+  var _status = 'idle';   // idle | unsupported | connecting | connected | rejected | dropped
   var _filesChangedCallbacks = [];
   var _fileSavedCallbacks = [];
   var _presenceCallbacks = [];
@@ -98,6 +103,7 @@ var WebSocketService = (function () {
     }
 
     _lastCableAttemptAt = Date.now();
+    if (_status !== 'rejected') _status = 'connecting';
 
     try {
       _consumer = _getConsumer();
@@ -106,12 +112,15 @@ var WebSocketService = (function () {
         {
           connected: function () {
             _connected = true;
+            _status = 'connected';
           },
           disconnected: function () {
+            _status = _status === 'rejected' ? 'rejected' : 'dropped';
             _cleanupConsumer();
             _scheduleReconnect();
           },
           rejected: function () {
+            _status = 'rejected';
             _cleanupConsumer();
             _scheduleReconnect();
           },
@@ -180,6 +189,7 @@ var WebSocketService = (function () {
   function connect(serverSupportsWs) {
     _serverSupportsWs = !!serverSupportsWs;
     if (!_serverSupportsWs || !_isActionCableAvailable()) {
+      _status = 'unsupported';
       return; // polling remains the only refresh mechanism
     }
     _installUnhandledRejectionGuard();
@@ -201,6 +211,12 @@ var WebSocketService = (function () {
     return _connected;
   }
 
+  // Coarse state of the editor's own cable subscription, for the collaboration
+  // diagnostics panel.
+  function cableStatus() {
+    return _status;
+  }
+
   // 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.
@@ -290,6 +306,7 @@ var WebSocketService = (function () {
     connect: connect,
     disconnect: disconnect,
     isConnected: isConnected,
+    cableStatus: cableStatus,
     isCableAvailable: isCableAvailable,
     subscribeCollaboration: subscribeCollaboration,
     perform: perform,

data/app/assets/stylesheets/mbeditor/editor.css

@@ -3395,3 +3395,31 @@ input.ide-model-graph-search[type="search"] {
   font-style: italic;
   opacity: 0.8;
 }
+
+/* Pair-programming diagnostics. The chip only appears when a condition pairing
+   needs has actually failed — an empty room is silence, not a warning. */
+.mbeditor-collab-trouble { color: var(--ide-warning, #cca700); }
+.mbeditor-modal-backdrop {
+  position: fixed; inset: 0; z-index: 5000;
+  background: rgba(0, 0, 0, 0.45);
+  display: flex; align-items: center; justify-content: center;
+}
+.mbeditor-collab-diag {
+  width: min(560px, 92vw);
+  max-height: 80vh; overflow-y: auto;
+  padding: 18px 20px;
+  background: var(--ide-panel-bg, #252526);
+  border: 1px solid var(--ide-border, #3c3c3c);
+  border-radius: 8px;
+  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.5);
+  color: var(--ide-text, #d4d4d4);
+  font-size: 12px;
+}
+.mbeditor-collab-diag-title { font-size: 14px; font-weight: 600; margin-bottom: 12px; }
+.mbeditor-collab-diag-list { list-style: none; margin: 0 0 12px; padding: 0; }
+.mbeditor-collab-diag-row { display: flex; gap: 9px; align-items: flex-start; padding: 6px 0; }
+.mbeditor-collab-diag-row i { margin-top: 2px; color: var(--ide-success, #4ec9b0); }
+.mbeditor-collab-diag-row.is-bad i { color: var(--ide-danger, #f14c4c); }
+.mbeditor-collab-diag-label { font-weight: 500; }
+.mbeditor-collab-diag-detail { color: var(--ide-text-muted, #858585); margin-top: 3px; line-height: 1.5; }
+.mbeditor-collab-diag-foot { color: var(--ide-text-muted, #858585); margin-bottom: 12px; }

data/app/channels/mbeditor/channel_authentication.rb

@@ -19,20 +19,49 @@ module Mbeditor
     # True when the connection is allowed (or no hook is configured); otherwise
     # rejects the subscription and returns false.
     def mbeditor_authenticated?
-      hook = Mbeditor.configuration.authenticate_with
+      hook = mbeditor_auth_hook
       return true unless hook
 
       probe = AuthProbe.new(mbeditor_connection_env)
       probe.instance_exec(&hook)
       return true unless probe.denied?
 
+      # Both denial paths used to be completely silent, which is what makes this
+      # so hard to diagnose: pairing simply never works and nothing anywhere says
+      # why. The commonest cause is a hook that reads state a controller filter
+      # populates — Current.user, an Authlogic session — because a WebSocket
+      # subscribe runs no controller, so that state is nil or raises here while
+      # working perfectly over HTTP.
+      mbeditor_log_denial("the authenticate_with hook denied the connection")
       mbeditor_reject_subscription
       false
-    rescue StandardError
+    rescue StandardError => e
+      mbeditor_log_denial("the authenticate_with hook raised #{e.class}: #{e.message}")
       mbeditor_reject_subscription
       false
     end
 
+    # `cable_authenticate_with` when set, otherwise the HTTP hook. A hook that
+    # depends on controller filters cannot work here at all, and asking people to
+    # write one proc that straddles both contexts is worse than letting them
+    # supply the cable one explicitly.
+    def mbeditor_auth_hook
+      Mbeditor.configuration.cable_authenticate_with ||
+        Mbeditor.configuration.authenticate_with
+    end
+
+    def mbeditor_log_denial(reason)
+      Rails.logger&.warn(
+        "[mbeditor] WebSocket subscription rejected: #{reason}. " \
+        "Realtime collaboration will not work. A WebSocket subscribe runs no " \
+        "controller, so Current.*, Authlogic sessions and other request-scoped " \
+        "state set by before_actions are unavailable here — resolve the user " \
+        "from `session` instead, or set config.cable_authenticate_with."
+      )
+    rescue StandardError
+      # Logging must never be the thing that breaks the socket.
+    end
+
     private
 
     def mbeditor_connection_env

data/lib/mbeditor/configuration.rb

@@ -5,7 +5,7 @@ module Mbeditor
     attr_accessor :allowed_environments, :workspace_root, :excluded_paths, :rubocop_command, :rubocop_server,
                   :redmine_enabled, :redmine_url, :redmine_api_key, :redmine_ticket_source,
                   :test_framework, :test_command, :test_timeout,
-                  :authenticate_with, :authentication_cache_ttl, :user_name_callback, :user_name_methods,
+                  :authenticate_with, :cable_authenticate_with, :authentication_cache_ttl, :user_name_callback, :user_name_methods,
                   :lint_timeout, :base_branch_candidates, :git_timeout, :search_timeout,
                   :ruby_def_include_dirs, :related_files_custom_paths,
                   :mount_path, :resilient_routing, :js_global_identifiers,
@@ -58,6 +58,16 @@ module Mbeditor
       @ruby_def_include_dirs  = %w[app/models app/controllers app/helpers app/concerns]
       @related_files_custom_paths = []
       @authentication_cache_ttl = 0
+      # Authentication for the collaboration WebSocket. nil falls back to
+      # authenticate_with.
+      #
+      # Exists because the two contexts genuinely differ: a WebSocket subscribe
+      # runs no controller, so anything a before_action populates —
+      # ActiveSupport::CurrentAttributes, an Authlogic session, a memoised
+      # current_user — is nil or raises here, and the hook then denies the socket
+      # while working perfectly over HTTP. Set this to a proc that resolves the
+      # user from `session` directly when the HTTP hook cannot.
+      @cable_authenticate_with = nil
       @user_name_callback = nil # proc resolved in controller context (instance_exec) → collaboration display name; nil falls through to current_user, then to the client-generated name
       # Attributes tried on current_user, in order, when no user_name_callback
       # is set. First non-blank one wins. Name your own column here rather than

data/lib/mbeditor/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.12.3
 platform: ruby
 authors:
 - Oliver Noonan