mbeditor 0.12.9 → 0.13.1

data/app/services/mbeditor/search_replace_service.rb

@@ -23,6 +23,12 @@ module Mbeditor
     MAX_RESULTS = 10_000
     RESULT_CACHE_TTL = 30 # seconds; also invalidated on mbeditor file mutations
     RESULT_CACHE_MAX_ENTRIES = 3
+    # A user-supplied regex is matched in-process, and Timeout.timeout cannot
+    # interrupt a CRuby regex — only Regexp's own timeout (Ruby >= 3.2) can.
+    # Below that the gemspec floor (3.0) leaves a catastrophic pattern
+    # unguarded, which is the pre-existing behaviour.
+    REGEXP_TIMEOUT = 1 # seconds
+    REGEXP_TIMEOUT_SUPPORTED = Regexp.method_defined?(:timeout)
 
     STATE_MUTEX = Mutex.new
     private_constant :STATE_MUTEX
@@ -112,6 +118,10 @@ module Mbeditor
           else
             @result_cache = {}
           end
+          # Bumped so a scan already in flight can tell its results are stale
+          # and skip filling the cache it just emptied. One counter for every
+          # root: an unrelated invalidation only costs a cache miss.
+          @cache_generation = (@cache_generation || 0) + 1
         end
       end
 
@@ -153,7 +163,14 @@ module Mbeditor
               content = File.binread(full_path).force_encoding("UTF-8")
                            .encode("UTF-8", invalid: :replace, undef: :replace)
               replacements_in_file = content.scan(pattern).length
-              new_content = content.gsub(pattern, replacement)
+              # Block form for a literal search: the two-argument gsub expands
+              # \1, \& and \\ in the replacement, which a non-regex replace
+              # must insert verbatim.
+              new_content = if use_regex
+                content.gsub(pattern, replacement)
+              else
+                content.gsub(pattern) { replacement }
+              end
               if new_content != content
                 File.binwrite(full_path, new_content.encode("UTF-8", invalid: :replace, undef: :replace))
                 files_affected << rel_path
@@ -185,10 +202,12 @@ module Mbeditor
         key = [workspace_root.to_s, query, use_regex, match_case, whole_word,
                Array(excluded_paths).map(&:to_s).sort]
         now = monotonic
-        STATE_MUTEX.synchronize do
+        generation = STATE_MUTEX.synchronize do
           @result_cache ||= {}
           entry = @result_cache[key]
           return entry[:data] if entry && (now - entry[:ts]) < RESULT_CACHE_TTL
+
+          @cache_generation ||= 0
         end
 
         data = scan(workspace_root, query, use_regex: use_regex, match_case: match_case,
@@ -198,6 +217,10 @@ module Mbeditor
         # Don't cache superseded scans — their results are truncated by the kill.
         unless data[:superseded]
           STATE_MUTEX.synchronize do
+            # A save landed while this scan ran: these rows predate it, and
+            # storing them now would serve pre-save matches for a full TTL.
+            next if (@cache_generation ||= 0) != generation
+
             @result_cache[key] = { ts: monotonic, data: data }
             @result_cache.delete(@result_cache.keys.first) while @result_cache.length > RESULT_CACHE_MAX_ENTRIES
           end
@@ -370,7 +393,8 @@ module Mbeditor
           return {
             file: relative_path(md.dig("path", "text").to_s, root),
             line: md.dig("line_number"),
-            text: raw_text.strip
+            text: raw_text.strip,
+            lead: leading_ws(raw_text)
           }.merge(cols)
         end
 
@@ -389,10 +413,18 @@ module Mbeditor
         end
 
         raw_text = Regexp.last_match(3)
-        { file: file_path, line: Regexp.last_match(2).to_i, text: raw_text.strip }
+        { file: file_path, line: Regexp.last_match(2).to_i, text: raw_text.strip, lead: leading_ws(raw_text) }
           .merge(match_columns(raw_text, pattern))
       end
 
+      # How many characters `strip` took off the FRONT of the line. `col`/
+      # `end_col` are measured against the raw line (see match_columns), so
+      # without this the client cannot say where the match sits inside the
+      # trimmed `text` it renders — which is what highlighting needs.
+      def leading_ws(raw_text)
+        raw_text.length - raw_text.lstrip.length
+      end
+
       # 1-based Monaco columns for the first match on a hit line. Returns an
       # empty hash when there is no usable pattern or it doesn't match — the
       # row is still a valid result, it just opens at the start of the line.
@@ -446,11 +478,14 @@ module Mbeditor
 
       def build_pattern(query, use_regex:, match_case:, whole_word:)
         flags = match_case ? 0 : Regexp::IGNORECASE
-        if use_regex
-          Regexp.new(whole_word ? "\\b(?:#{query})\\b" : query, flags)
+        source = if use_regex
+          whole_word ? "\\b(?:#{query})\\b" : query
         else
-          Regexp.new(whole_word ? "\\b#{Regexp.escape(query)}\\b" : Regexp.escape(query), flags)
+          whole_word ? "\\b#{Regexp.escape(query)}\\b" : Regexp.escape(query)
         end
+        return Regexp.new(source, flags, timeout: REGEXP_TIMEOUT) if REGEXP_TIMEOUT_SUPPORTED
+
+        Regexp.new(source, flags)
       end
 
       def relative_path(absolute_path, workspace_root)

data/app/services/mbeditor/test_runner_service.rb

@@ -10,6 +10,11 @@ module Mbeditor
   # Follows the same process-group kill pattern used by the lint endpoint to
   # enforce a configurable timeout.
   module TestRunnerService
+    # Cap on the output shipped to the browser. A verbose run emits megabytes
+    # of it, and the tail is the part that matters (the failure list and the
+    # summary). Parsing still sees the full output.
+    MAX_RAW_BYTES = 256_000
+
     module_function
 
     # Run the test file at +test_path+ inside +repo_path+.
@@ -26,13 +31,13 @@ module Mbeditor
 
       cmd = build_command(repo_path, test_path, framework, command, line: line)
       raw = execute_with_timeout(repo_path, cmd, timeout)
-      tests, summary = parse_output(raw, framework)
+      tests, summary = parse_output(raw, framework, repo_path: repo_path)
       {
         ok: true,
         framework: framework.to_s,
         summary: summary,
         tests: tests,
-        raw: raw
+        raw: truncate_raw(raw)
       }
     rescue ProcessRunner::TimeoutError
       error_result("Test run timed out after #{timeout} seconds")
@@ -176,18 +181,44 @@ module Mbeditor
       result[:stdout] + result[:stderr]
     end
 
-    def parse_output(raw, framework)
+    # Keeps the tail. byteslice can cut a multi-byte character in half, so the
+    # result is scrubbed before it goes anywhere near JSON.
+    def truncate_raw(raw)
+      return raw if raw.bytesize <= MAX_RAW_BYTES
+
+      raw.byteslice(-MAX_RAW_BYTES, MAX_RAW_BYTES).scrub
+    end
+
+    def parse_output(raw, framework, repo_path: nil)
       case framework.to_sym
       when :rspec
-        parse_rspec_output(raw)
+        parse_rspec_output(raw, repo_path: repo_path)
       when :minitest
-        parse_minitest_output(raw)
+        parse_minitest_output(raw, repo_path: repo_path)
       else
         [[], empty_summary]
       end
     end
 
-    def parse_rspec_output(raw)
+    # Failure blocks name an absolute path in some runners and a repo-relative
+    # one in others. The editor can only open the relative form, so both are
+    # normalized here; anything that escapes the workspace is dropped rather
+    # than handed to the client as an unopenable path.
+    def relativize(path, repo_path)
+      return nil if path.nil? || path.empty?
+
+      rel = path.to_s
+      rel = rel.delete_prefix("./")
+      if repo_path
+        root = File.join(repo_path.to_s.chomp("/"), "")
+        rel = rel.delete_prefix(root)
+      end
+      return nil if rel.start_with?("/", "../")
+
+      rel
+    end
+
+    def parse_rspec_output(raw, repo_path: nil)
       # RSpec with --format json embeds JSON in the output
       json_match = raw.match(/(\{.*"summary_line".*\})/m)
       if json_match
@@ -205,18 +236,19 @@ module Mbeditor
             name: ex["full_description"] || ex["description"],
             status: ex["status"] == "passed" ? "pass" : (ex["status"] == "pending" ? "skip" : "fail"),
             line: ex.dig("line_number"),
+            file: relativize(ex["file_path"], repo_path),
             message: ex.dig("exception", "message")
           }
         end
         [tests, summary]
       else
-        parse_minitest_output(raw) # fallback to text parsing
+        parse_minitest_output(raw, repo_path: repo_path) # fallback to text parsing
       end
     rescue JSON::ParserError
-      parse_minitest_output(raw)
+      parse_minitest_output(raw, repo_path: repo_path)
     end
 
-    def parse_minitest_output(raw)
+    def parse_minitest_output(raw, repo_path: nil)
       lines = raw.lines
 
       # First pass: collect per-test results from verbose output.
@@ -232,7 +264,7 @@ module Mbeditor
                  when "E" then "error"
                  when "S" then "skip"
                  end
-        verbose_results[m[1]] = { name: m[1], status: status, line: nil, message: nil }
+        verbose_results[m[1]] = { name: m[1], status: status, line: nil, file: nil, message: nil }
       end
 
       # Second pass: parse failure/error blocks for messages and line numbers.
@@ -246,6 +278,7 @@ module Mbeditor
 
         name = name_line.strip.split(" [").first.chomp(":")
         line_num = name_line[/:(\d+)\]/, 1]&.to_i
+        file = relativize(name_line[/\[([^\]]+):\d+\]/, 1], repo_path)
         msg_lines = []
         (idx + 2...lines.length).each do |j|
           break if lines[j].strip.empty? || lines[j].match?(/^\s+\d+\)\s+/)
@@ -256,11 +289,13 @@ module Mbeditor
           name: name,
           status: line.include?("Error") ? "error" : "fail",
           line: line_num,
+          file: file,
           message: msg_lines.join("\n")
         }
 
         if verbose_results.key?(name)
           verbose_results[name][:line]    = line_num
+          verbose_results[name][:file]    = file
           verbose_results[name][:message] = msg_lines.join("\n")
         else
           failure_entries << entry

data/lib/mbeditor/cable_log_filter.rb

@@ -62,8 +62,14 @@ module Mbeditor
 
     %w[debug info warn error fatal unknown].each do |level|
       define_method(level) do |message = nil, &block|
-        msg = message.nil? && block ? block.call : message.to_s
-        return if suppress_message?(msg)
+        # Evaluate the block exactly once. It used to be called for the
+        # suppression check and then handed to super as well, so every message
+        # that got through was built twice.
+        if message.nil? && block
+          message = block.call
+          block = nil
+        end
+        return if suppress_message?(message.to_s)
 
         super(message, &block)
       end

data/lib/mbeditor/configuration.rb

@@ -27,7 +27,10 @@ module Mbeditor
       @redmine_ticket_source = :commit # :commit (scan commit messages) or :branch (leading digits of branch name)
       @test_framework   = nil # :minitest or :rspec — auto-detected when nil
       @test_command     = nil # e.g. "bundle exec ruby -Itest" or "bundle exec rspec"
-      @test_timeout     = 60  # seconds
+      # Seconds. 60 was not enough for a real app: `bin/rails test` spends most
+      # of it booting Rails before the first assertion runs, so a perfectly
+      # healthy single-file run reported "timed out".
+      @test_timeout     = 180
       @lint_timeout     = 15  # seconds for RuboCop/haml-lint subprocesses
       @base_branch_candidates = %w[origin/develop origin/main origin/master develop main master]
       @git_timeout            = 10 # seconds; nil disables (no timeout on git subprocesses)

data/lib/mbeditor/editor_bootstrap.rb

@@ -55,27 +55,33 @@ module Mbeditor
 
           window.loadPrettierPlugins = function() {
             if (window._prettierLoadPromise) return window._prettierLoadPromise;
-            window._prettierLoadPromise = new Promise(function(resolve, reject) {
+            var promise = new Promise(function(resolve, reject) {
               var savedDefine = window.define;
               window.define = undefined;
               var pending = prettierScripts.length;
+              var failed = null;
+              // Restore window.define only once every script has settled: an
+              // early restore let a sibling still in flight register as an AMD
+              // module instead of setting its window global.
+              function settle() {
+                if (--pending > 0) return;
+                window.define = savedDefine;
+                if (failed) reject(new Error('Failed to load Prettier: ' + failed));
+                else resolve();
+              }
               prettierScripts.forEach(function(src) {
                 var s = document.createElement('script');
                 s.src = src;
-                s.onload = function() {
-                  if (--pending === 0) {
-                    window.define = savedDefine;
-                    resolve();
-                  }
-                };
-                s.onerror = function() {
-                  window.define = savedDefine;
-                  reject(new Error('Failed to load Prettier: ' + src));
-                };
+                s.onload = settle;
+                s.onerror = function() { failed = failed || src; settle(); };
                 document.head.appendChild(s);
               });
             });
-            return window._prettierLoadPromise;
+            window._prettierLoadPromise = promise;
+            // Clear the cached promise so the next Format action retries the
+            // load; caching a rejection disabled Format for the whole session.
+            promise.catch(function() { window._prettierLoadPromise = null; });
+            return promise;
           };
 
           // Lazy-load monaco-vim on first use. Drop-in for the old AMD

data/lib/mbeditor/engine.rb

@@ -2,6 +2,7 @@
 
 require "mbeditor/rack/silence_ping_request"
 require "mbeditor/rack/handle_pending_migrations"
+require "mbeditor/rack/pending_migration_bypass"
 require "mbeditor/rack/resilient_router"
 require "mbeditor/cable_log_filter"
 
@@ -71,7 +72,24 @@ module Mbeditor
                         app.config.active_record[:migration_error]
 
       if defined?(ActiveRecord::Migration::CheckPending) && migration_error == :page_load
-        app.middleware.insert_before ActiveRecord::Migration::CheckPending,
+        # Two layers, and both earn their place.
+        #
+        # The swap is the actual fix: CheckPending is replaced by a wrapper that
+        # runs the identical check for the host's own traffic, but records
+        # rather than raises for the editor's — so a pending migration no longer
+        # blocks the tree, opening a file, saving one, or loading the assets the
+        # page needs. Without it the editor was unusable exactly when it was
+        # needed most.
+        app.middleware.swap ActiveRecord::Migration::CheckPending,
+                            Mbeditor::Rack::PendingMigrationBypass,
+                            file_watcher: app.config.file_watcher
+
+        # HandlePendingMigrations stays above it as a backstop for a
+        # PendingMigrationError raised from anywhere else in the stack (an
+        # engine or initializer that checks on its own). It should now be
+        # unreachable for the ordinary case; it is cheap, and being locked out
+        # of the editor is the failure worth two guards.
+        app.middleware.insert_before Mbeditor::Rack::PendingMigrationBypass,
                                      Mbeditor::Rack::HandlePendingMigrations
       end
     end
@@ -156,8 +174,9 @@ module Mbeditor
 
       @exception_subscriber = ActiveSupport::Notifications.subscribe(
         "process_action.action_controller"
-      ) do |*args|
-        payload = ActiveSupport::Notifications::Event.new(*args).payload
+      ) do |_name, _started, _finished, _id, payload|
+        # 5-arity: the block runs for every host request, and building an Event
+        # just to read its payload allocated one per request for nothing.
         exception = payload[:exception_object]
         next unless exception
 

data/lib/mbeditor/exception_log.rb

@@ -48,10 +48,10 @@ module Mbeditor
       private
 
       def build(exception, payload, workspace_root)
-        @seq = (@seq || 0) + 1
+        seq = MUTEX.synchronize { @seq = (@seq || 0) + 1 }
         {
           type: "exception",
-          id: @seq,
+          id: seq,
           at: Time.now.utc.iso8601,
           klass: exception.class.name,
           message: exception.message.to_s[0, 2000],

data/lib/mbeditor/pending_migrations.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # The last pending-migration message seen, so the editor can warn about it
+  # without being blocked by it.
+  #
+  # Lives in lib/ (not autoloaded) for the same reason ExceptionLog does: a
+  # Zeitwerk reload must not wipe it, and a pending migration is exactly the
+  # state in which reloads are happening.
+  module PendingMigrations
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    module_function
+
+    # message: the PendingMigrationError's message, or nil once it clears.
+    def note(message)
+      MUTEX.synchronize { @message = message && message.to_s.strip }
+    end
+
+    def clear
+      MUTEX.synchronize { @message = nil }
+    end
+
+    def message
+      MUTEX.synchronize { @message }
+    end
+
+    def pending?
+      !message.nil?
+    end
+  end
+end

data/lib/mbeditor/rack/handle_pending_migrations.rb

@@ -18,7 +18,7 @@ module Mbeditor
         raise unless defined?(ActiveRecord::PendingMigrationError) && e.is_a?(ActiveRecord::PendingMigrationError)
 
         path = "#{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}"
-        raise unless path.start_with?("/mbeditor")
+        raise unless path.start_with?(Mbeditor::MountPath.resolve)
 
         if env["HTTP_X_MBEDITOR_CLIENT"] == "1"
           # XHR from the editor frontend — structured JSON error.
@@ -30,13 +30,23 @@ module Mbeditor
           # files. Assets are referenced by their unfingerprinted paths, which
           # Sprockets resolves in development (the only env mbeditor runs in).
           # The banner appears as soon as the first XHR fires.
-          base = env["SCRIPT_NAME"].to_s.sub(%r{/$}, "")
-          [200, { "Content-Type" => "text/html; charset=utf-8" }, [editor_shell_html(base)]]
+          #
+          # The base comes from MountPath, not SCRIPT_NAME: this middleware runs
+          # above the router, so SCRIPT_NAME is still "" and the engine-served
+          # URLs in the shell (/monaco-editor/...) were emitted without the
+          # mount prefix and 404'd.
+          [200, { "Content-Type" => "text/html; charset=utf-8" }, [editor_shell_html(mount_base)]]
         end
       end
 
       private
 
+      def mount_base
+        Mbeditor::MountPath.resolve.to_s.sub(%r{/$}, "")
+      rescue StandardError
+        ""
+      end
+
       def editor_shell_html(base)
         prettier_script_urls = %w[
           prettier-standalone.js
@@ -45,14 +55,14 @@ module Mbeditor
           prettier-plugin-html.js
           prettier-plugin-postcss.js
           prettier-plugin-markdown.js
-        ].map { |f| "#{base}/assets/#{f}" }
+        ].map { |f| "/assets/#{f}" }
 
         # Bootstrap JS shared with the standard layout — see Mbeditor::EditorBootstrap
         setup_js = Mbeditor::EditorBootstrap.setup_js(base)
         boot_js  = Mbeditor::EditorBootstrap.boot_js(
           base: base,
           prettier_script_urls: prettier_script_urls,
-          application_js_url: "#{base}/assets/mbeditor/application.js"
+          application_js_url: "/assets/mbeditor/application.js"
         )
 
         <<~HTML
@@ -62,16 +72,16 @@ module Mbeditor
             <meta charset="UTF-8" />
             <meta name="viewport" content="width=device-width, initial-scale=1.0" />
             <title>Mbeditor</title>
-            <link rel="stylesheet" href="#{base}/assets/fontawesome.min.css" />
-            <link rel="stylesheet" href="#{base}/assets/mbeditor/application.css" />
-            <script defer src="#{base}/assets/react.min.js"></script>
-            <script defer src="#{base}/assets/react-dom.min.js"></script>
-            <script defer src="#{base}/assets/axios.min.js"></script>
-            <script defer src="#{base}/assets/lodash.min.js"></script>
-            <script defer src="#{base}/assets/minisearch.min.js"></script>
-            <script defer src="#{base}/assets/marked.min.js"></script>
-            <script defer src="#{base}/assets/emmet.js"></script>
-            <script defer src="#{base}/assets/monaco-themes-bundle.js"></script>
+            <link rel="stylesheet" href="/assets/fontawesome.min.css" />
+            <link rel="stylesheet" href="/assets/mbeditor/application.css" />
+            <script defer src="/assets/react.min.js"></script>
+            <script defer src="/assets/react-dom.min.js"></script>
+            <script defer src="/assets/axios.min.js"></script>
+            <script defer src="/assets/lodash.min.js"></script>
+            <script defer src="/assets/minisearch.min.js"></script>
+            <script defer src="/assets/marked.min.js"></script>
+            <script defer src="/assets/emmet.js"></script>
+            <script defer src="/assets/monaco-themes-bundle.js"></script>
             <link rel="stylesheet" href="#{base}/monaco-editor/monaco.css" />
           </head>
           <body>

data/lib/mbeditor/rack/pending_migration_bypass.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "mbeditor/pending_migrations"
+
+module Mbeditor
+  module Rack
+    # Wraps ActiveRecord::Migration::CheckPending so a pending migration cannot
+    # lock the developer out of the one tool they need to fix it.
+    #
+    # Rails inserts CheckPending after ActionDispatch::Callbacks whenever
+    # config.active_record.migration_error is :page_load — the default a real
+    # `rails new` app carries in development. From then until the migration is
+    # run, EVERY request raises PendingMigrationError, and that included all of
+    # mbeditor's: the file tree, opening a file, and saving one. The editor was
+    # unusable in precisely the situation it exists to get you out of, and the
+    # migration could not be edited to fix it.
+    #
+    # An earlier attempt rescued the error above CheckPending and answered
+    # mbeditor's own paths with a fallback shell and a 503 for every XHR. That
+    # left the shell without its stylesheets or JavaScript — those live under
+    # /assets, which is not an mbeditor path, so they still 500'd — and even
+    # once loaded every API call was a 503. Rescuing after the fact was the
+    # wrong shape; the check simply must not apply to this traffic.
+    #
+    # So the check still runs (it is file-watcher backed and cheap after the
+    # first call, and non-editor traffic must keep Rails' behaviour exactly),
+    # but for editor traffic the error is recorded and swallowed rather than
+    # raised, and the request proceeds. CheckPending raises before it calls
+    # anything downstream, so dispatching afterwards runs the request once, not
+    # twice.
+    #
+    # The recorded message is what surfaces the warning banner, so the developer
+    # is still told to migrate — they are just no longer prevented from working.
+    class PendingMigrationBypass
+      DEFAULT_ASSET_PREFIX = "/assets"
+
+      def initialize(app, file_watcher: nil)
+        @app = app
+        @checked =
+          if file_watcher
+            ActiveRecord::Migration::CheckPending.new(app, file_watcher: file_watcher)
+          else
+            ActiveRecord::Migration::CheckPending.new(app)
+          end
+      end
+
+      # Announced on every bypassed response so the editor can warn about a
+      # migration created mid-session, not only one that existed at page load.
+      PENDING_HEADER = "X-Mbeditor-Pending-Migration"
+
+      def call(env)
+        return @checked.call(env) unless editor_traffic?(env)
+
+        begin
+          result = @checked.call(env)
+          # The check passed, so anything recorded earlier is stale.
+          Mbeditor::PendingMigrations.clear
+          result
+        rescue StandardError => e
+          raise unless pending_migration_error?(e)
+
+          Mbeditor::PendingMigrations.note(e.message)
+          status, headers, body = @app.call(env)
+          headers[PENDING_HEADER] = header_safe(e.message)
+          [status, headers, body]
+        end
+      end
+
+      private
+
+      # A header cannot carry the newlines the error message has, and it does
+      # not need the whole thing — the banner supplies the instructions.
+      def header_safe(message)
+        message.to_s.gsub(/\s+/, " ").strip[0, 200]
+      end
+
+      def pending_migration_error?(error)
+        defined?(ActiveRecord::PendingMigrationError) &&
+          error.is_a?(ActiveRecord::PendingMigrationError)
+      end
+
+      # Everything the editor needs in order to load and function: its own mount
+      # and the assets its page pulls in. Asset requests are included because
+      # the shell is inert without them — and because serving a stylesheet has
+      # never depended on the schema being current.
+      def editor_traffic?(env)
+        path = "#{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}"
+        prefix = Mbeditor::MountPath.resolve
+        return true if path == prefix || path.start_with?("#{prefix}/")
+
+        path.start_with?("#{asset_prefix}/")
+      end
+
+      def asset_prefix
+        @asset_prefix ||= begin
+          configured = Rails.application.config.assets.prefix if Rails.application.config.respond_to?(:assets)
+          (configured.presence || DEFAULT_ASSET_PREFIX).to_s.chomp("/")
+        rescue StandardError
+          DEFAULT_ASSET_PREFIX
+        end
+      end
+    end
+  end
+end

data/lib/mbeditor/rack/silence_ping_request.rb

@@ -35,7 +35,15 @@ module Mbeditor
       private
 
       def mbeditor_request?(path)
-        path.start_with?("/mbeditor/")
+        path.start_with?("#{mount_prefix}/")
+      end
+
+      # The mount is configurable, so the prefix cannot be hardcoded — a host
+      # that mounts the engine elsewhere logged every editor request in full.
+      def mount_prefix
+        Mbeditor::MountPath.resolve.chomp("/")
+      rescue StandardError
+        Mbeditor::MountPath::DEFAULT
       end
 
       def cable_request?(path)
@@ -53,7 +61,7 @@ module Mbeditor
       end
 
       def root_request?(env, path)
-        env["REQUEST_METHOD"] == "GET" && path == "/mbeditor"
+        env["REQUEST_METHOD"] == "GET" && path == mount_prefix
       end
 
       def normalized_request_path(env)

data/lib/mbeditor/route_map.rb

@@ -55,6 +55,7 @@ module Mbeditor
     post   'lint',            to: 'editors#lint'
     post   'quick_fix',       to: 'editors#quick_fix'
     post   'format',          to: 'editors#format_file'
+    post   'rubocop',         to: 'editors#rubocop_run'
     post   'test',            to: 'editors#run_test'
     get    'logs/tail',       to: 'logs#tail'