mbeditor 0.12.8 → 0.13.0

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 whole-suite 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")
@@ -40,6 +45,59 @@ module Mbeditor
       error_result(e.message)
     end
 
+    # Run the whole suite in +repo_path+ — no file argument, so the framework's
+    # own default target applies (test/ for Rails, spec/ for RSpec).
+    #
+    # Same return shape as +run+, so the panel renders one result type. The
+    # framework is detected from the project rather than from a filename,
+    # since there isn't one.
+    def run_all(repo_path, framework: nil, command: nil, timeout: 1800)
+      framework = detect_suite_framework(repo_path) if framework.nil?
+      return error_result("Could not detect test framework") unless framework
+
+      cmd = build_suite_command(repo_path, framework, command)
+      raw = execute_with_timeout(repo_path, cmd, timeout)
+      tests, summary = parse_output(raw, framework, repo_path: repo_path)
+      {
+        ok: true,
+        framework: framework.to_s,
+        summary: summary,
+        tests: tests,
+        raw: truncate_raw(raw)
+      }
+    rescue ProcessRunner::TimeoutError
+      error_result("Test run timed out after #{timeout} seconds")
+    rescue StandardError => e
+      error_result(e.message)
+    end
+
+    # No test_path to go on, so this reads the project layout only. RSpec wins
+    # a tie: a project with both usually keeps `test/` for legacy fixtures.
+    def detect_suite_framework(repo_path)
+      return :rspec if File.exist?(File.join(repo_path, ".rspec"))
+      return :rspec if File.directory?(File.join(repo_path, "spec"))
+      return :minitest if File.directory?(File.join(repo_path, "test"))
+
+      nil
+    end
+
+    def build_suite_command(repo_path, framework, custom_command)
+      return Shellwords.split(custom_command) if custom_command.present?
+
+      case framework.to_sym
+      when :rspec
+        bin = File.join(repo_path, "bin", "rspec")
+        (File.exist?(bin) ? [bin] : ["bundle", "exec", "rspec"]) + ["--format", "json"]
+      else
+        bin = File.join(repo_path, "bin", "rails")
+        # `bin/rails test` with no path runs the default suite. Without it,
+        # `rake test` is the portable fallback for a non-Rails project.
+        return [bin, "test", "--verbose"] if File.exist?(bin)
+
+        ["bundle", "exec", "rake", "test"]
+      end
+    end
+
     # Given a source file path, resolve it to its matching test/spec file.
     # If the file is already a test/spec file, return it as-is.
     def resolve_test_file(repo_path, relative_path)
@@ -176,18 +234,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 +289,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 +317,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 +331,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 +342,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

@@ -5,6 +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,
+                  :test_all_command, :test_all_timeout,
                   :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,
@@ -27,7 +28,17 @@ 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
+      # A whole-suite run is a different order of magnitude — minutes, not
+      # seconds — so it gets its own ceiling rather than forcing test_timeout
+      # up to a value that lets one hung example block for half an hour.
+      @test_all_timeout = 1800
+      # Sibling of test_command, for the same reason: a project that needs a
+      # custom runner for one file needs one for the suite too. nil auto-detects.
+      @test_all_command = nil
       @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,7 +55,9 @@ 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'
+    post   'test_all',        to: 'editors#run_all_tests'
     get    'logs/tail',       to: 'logs#tail'
 
     # ── Git & Code Review ──────────────────────────────────────────────────────