mbeditor 0.12.9 → 0.13.0

data/app/services/mbeditor/process_runner.rb

@@ -8,7 +8,13 @@ module Mbeditor
 
     class TimeoutError < StandardError; end
 
-    def call(cmd, timeout: nil, env: {}, stdin_data: nil, chdir: nil)
+    CHUNK_BYTES = 64 * 1024
+    private_constant :CHUNK_BYTES
+
+    # +max_bytes+ bounds how much of each stream is kept in memory (nil =
+    # unbounded). Anything past the cap is still read and discarded — stopping
+    # would block the child on a full pipe and hang the wait below.
+    def call(cmd, timeout: nil, env: {}, stdin_data: nil, chdir: nil, max_bytes: nil)
       out = +""
       err = +""
       exit_status = nil
@@ -21,28 +27,52 @@ module Mbeditor
         stdin.write(stdin_data) if stdin_data
         stdin.close
 
-        timer = if timeout
-          Thread.new do
-            sleep timeout
-            timed_out = true
-            Process.kill("-KILL", wait_thr.pid)
-          rescue Errno::ESRCH
-            nil
+        out_thread = Thread.new { out = read_capped(stdout, max_bytes) }
+        err_thread = Thread.new { err = read_capped(stderr, max_bytes) }
+
+        # A deadline join rather than a timer thread: a timer racing normal
+        # exit could flag a timeout (and SIGKILL a recycled pid) after the
+        # process had already succeeded. The reader threads above keep the
+        # pipes drained meanwhile, so this cannot deadlock.
+        if timeout
+          deadline  = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+          timed_out = !wait_thr.join(timeout)
+
+          # A grandchild that inherited the pipe holds it open after the child
+          # exits, so the unbounded joins below could outlive the process
+          # itself. Bound them by the same deadline the timer thread enforced.
+          remaining = [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
+          overrun   = !out_thread.join(remaining) || !err_thread.join(remaining)
+
+          if timed_out || overrun
+            begin
+              Process.kill("-KILL", wait_thr.pid)
+            rescue Errno::ESRCH
+              nil
+            end
           end
         end
 
-        out_thread = Thread.new { out = stdout.read }
-        err_thread = Thread.new { err = stderr.read }
         out_thread.join
         err_thread.join
-
         exit_status = wait_thr.value
-        timer&.kill
       end
 
       raise TimeoutError, "process timed out after #{timeout}s" if timed_out
 
       { stdout: out, stderr: err, exit_status: exit_status }
     end
+
+    def read_capped(io, max_bytes)
+      return io.read.to_s unless max_bytes
+
+      buf = +""
+      while (chunk = io.read(CHUNK_BYTES))
+        buf << chunk if buf.bytesize < max_bytes
+      end
+      # IO#read with a length returns binary; IO#read without one applies the
+      # default external encoding, and callers expect the latter.
+      buf.force_encoding(Encoding.default_external)
+    end
   end
 end

data/app/services/mbeditor/ri_definition_service.rb

@@ -30,6 +30,10 @@ module Mbeditor
       Struct Set Time File IO Exception Proc Method NilClass
     ].freeze
 
+    # Keyed by symbol, so a long session accumulates one entry per name ever
+    # hovered. Cleared wholesale at the cap — the next lookups just re-run ri.
+    MAX_CACHE_ENTRIES = 500
+
     @cache = {}
     @mutex = Mutex.new
 
@@ -39,7 +43,10 @@ module Mbeditor
         return cached unless cached.nil?
 
         result = new(symbol).call
-        @mutex.synchronize { @cache[symbol] = result }
+        @mutex.synchronize do
+          @cache.clear if @cache.size >= MAX_CACHE_ENTRIES
+          @cache[symbol] = result
+        end
         result
       end
 

data/app/services/mbeditor/route_service.rb

@@ -12,13 +12,6 @@ module Mbeditor
   module RouteService
     module_function
 
-    # Actions with no route are worth calling out, but only for controllers Rails
-    # would actually dispatch to. These are the inherited ones every controller
-    # has and nobody routes.
-    NON_ACTION_METHODS = %w[
-      new inspect method_of to_s hash class dup freeze
-    ].freeze
-
     # "app/controllers/admin/users_controller.rb" -> "admin/users", which is the
     # key Rails stores in a route's defaults.
     def controller_key(relative_path)
@@ -29,18 +22,62 @@ module Mbeditor
       match[1]
     end
 
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    # Matches the other read-through caches in this engine (FileTreeService 15s,
+    # GitInfoService 10s). A write invalidates it outright, so the TTL only ever
+    # bounds staleness from a route change made outside the editor.
+    CACHE_TTL = 10
+
     # => { "show" => [{ verb:, path:, name: }], ... }
+    #
+    # Cached because every call walks the host app's ENTIRE route set, and the
+    # caller is the inline route hints — which re-request on every activation of
+    # a controller tab and on every external content change. Switching between
+    # two controllers repeatedly was therefore a full O(routes) scan per switch,
+    # and a large app has thousands of routes. The scan itself is unchanged;
+    # it just stops happening once per glance.
     def for_controller(key)
       return {} if key.nil? || key.empty?
       return {} unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
 
-      routes_for(key)
+      cached = cached_routes(key)
+      return cached if cached
+
+      # Built outside the mutex: it runs arbitrary host-app route code, and
+      # holding the lock across it would serialise every other controller's
+      # lookup behind the slowest one.
+      computed = routes_for(key)
+      store_routes(key, computed)
+      computed
     rescue StandardError
       # A broken route set must not take the editor down with it — the file still
       # opens, just without hints.
       {}
     end
 
+    def invalidate
+      MUTEX.synchronize { @cache = {} }
+      nil
+    end
+
+    def cached_routes(key)
+      MUTEX.synchronize do
+        entry = (@cache ||= {})[key]
+        return entry[:data] if entry && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - entry[:ts]) < CACHE_TTL
+      end
+      nil
+    end
+    private_class_method :cached_routes
+
+    def store_routes(key, data)
+      MUTEX.synchronize do
+        (@cache ||= {})[key] = { ts: Process.clock_gettime(Process::CLOCK_MONOTONIC), data: data }
+      end
+    end
+    private_class_method :store_routes
+
     def routes_for(key)
       out = {}
       Rails.application.routes.routes.each do |route|

data/app/services/mbeditor/rubocop_run_service.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "json"
+require "tmpdir"
+
+module Mbeditor
+  # Whole-workspace `rubocop` run — the counterpart to the per-buffer /lint
+  # endpoint, which can only report on files Monaco already has open.
+  #
+  # `-a` (safe autocorrect) rather than `-A`: unsafe corrections can change
+  # behaviour, and this runs over every file in the project at once, so an
+  # unreviewed `-A` is a much bigger blast radius than the per-buffer quick fix.
+  module RubocopRunService
+    module_function
+
+    def run(workspace_root, mode: :check, timeout: 300)
+      matcher = ExclusionMatcher.new(Mbeditor.configuration.excluded_paths, root: workspace_root)
+      cmd = AvailabilityProbe.rubocop_command(workspace_root) +
+            [AvailabilityProbe.rubocop_server_flag(workspace_root), "--format", "json", "--no-color"]
+      cmd << "-a" if mode.to_sym == :autocorrect
+
+      result = ProcessRunner.call(
+        cmd,
+        timeout: timeout,
+        chdir: workspace_root.to_s,
+        env: { "RUBOCOP_CACHE_ROOT" => File.join(Dir.tmpdir, "rubocop") }
+      )
+      parse(result[:stdout], result[:stderr], matcher)
+    rescue ProcessRunner::TimeoutError
+      error("RuboCop timed out after #{timeout}s")
+    rescue StandardError => e
+      error(e.message)
+    end
+
+    # RuboCop writes its JSON to stdout, but anything the host app prints while
+    # loading (a deprecation warning, a bundler notice) lands in front of it —
+    # hence the seek to the first brace, same as the /lint path.
+    # +matcher+ drops offenses in paths the workspace excludes — vendored gems
+    # above all. RuboCop's own defaults exclude `vendor/**/*`, but a host
+    # .rubocop.yml that sets AllCops/Exclude without `inherit_mode: merge`
+    # silently replaces them, and the panel then fills with gem source.
+    #
+    # ponytail: filtered after the fact, so a host in that state still pays for
+    # the walk. Generate a config that inherits from theirs and re-adds the
+    # excludes if the run time ever becomes the complaint.
+    def parse(stdout, stderr = nil, matcher = nil)
+      idx = stdout.index("{")
+      return error(stderr.to_s.strip.split("\n").last || "RuboCop produced no output") unless idx
+
+      data = JSON.parse(stdout[idx..])
+      files = (data["files"] || []).filter_map do |file|
+        next if matcher&.excluded?(file["path"].to_s)
+
+        offenses = file["offenses"] || []
+        next if offenses.empty?
+
+        { path: file["path"], offenses: offenses.map { |o| offense(o) } }
+      end
+
+      {
+        ok: true,
+        files: files.sort_by { |f| f[:path].to_s },
+        summary: data["summary"] || {},
+        correctable: files.sum { |f| f[:offenses].count { |o| o[:correctable] } }
+      }
+    rescue JSON::ParserError => e
+      error(e.message)
+    end
+
+    def offense(o)
+      {
+        copName: o["cop_name"],
+        message: o["message"],
+        severity: o["severity"],
+        correctable: o["correctable"] == true,
+        corrected: o["corrected"] == true,
+        line: o.dig("location", "start_line") || o.dig("location", "line") || 1,
+        column: o.dig("location", "start_column") || o.dig("location", "column") || 1
+      }
+    end
+
+    def error(message)
+      { ok: false, error: message, files: [], summary: {}, correctable: 0 }
+    end
+  end
+end

data/app/services/mbeditor/ruby_definition_service.rb

@@ -34,6 +34,8 @@ module Mbeditor
     # Upper bound on cached files. Entries carry full file contents, so this
     # caps both the on-disk JSON and the resident hash.
     MAX_CACHE_ENTRIES = 2_000
+    # Minimum gap between disk writes of that cache (seconds).
+    PERSIST_INTERVAL = 30
 
     # In-process file-index cache.
     # Structure: { absolute_path => {
@@ -63,6 +65,7 @@ module Mbeditor
       def clear_cache!
         @mutex.synchronize { @file_cache.clear; @cache_loaded = false }
         @last_evict_at = nil
+        @last_persist_at = nil
         path = @cache_path.to_s
         File.delete(path) if !path.empty? && File.exist?(path)
       rescue StandardError
@@ -154,10 +157,18 @@ module Mbeditor
       end
 
       # Atomically write the in-memory cache to disk (tmp-file + rename).
+      # Debounced: the snapshot carries every cached file's full source, so a
+      # lookup that parsed one new file would otherwise rewrite tens of MB of
+      # JSON. Skipping a write only delays it — the entries stay in memory and
+      # a later lookup flushes them.
       def persist_cache
         path = @cache_path.to_s
         return if path.empty?
 
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return if @last_persist_at && (now - @last_persist_at) < PERSIST_INTERVAL
+
+        @last_persist_at = now
         snapshot = @mutex.synchronize do
           # Each entry holds the file's full source lines, so an uncapped cache
           # grows to tens of MB on a large workspace and is rewritten in full on
@@ -263,7 +274,10 @@ module Mbeditor
                 signature: (cached[:lines][def_line - 1] || "").strip,
                 comments:  extract_comments(cached[:lines], def_line)
               }
-              return results if results.length >= MAX_RESULTS
+              if results.length >= MAX_RESULTS
+                persist_cache if @new_entries
+                return results
+              end
             end
           rescue StandardError
             # Malformed file or unreadable; skip silently
@@ -284,14 +298,19 @@ module Mbeditor
 
     def evict_deleted_cache_entries
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      stale_keys = @shared_mutex.synchronize do
+      keys = @shared_mutex.synchronize do
         last = self.class.instance_variable_get(:@last_evict_at)
         next nil if last && (now - last) < EVICT_INTERVAL
 
         self.class.instance_variable_set(:@last_evict_at, now)
-        @shared_cache.keys.select { |p| !File.exist?(p) }
+        @shared_cache.keys
       end
-      return if stale_keys.nil? || stale_keys.empty?
+      return if keys.nil?
+
+      # stat()ing outside the lock: up to MAX_CACHE_ENTRIES syscalls, and every
+      # other cache reader would otherwise wait on them.
+      stale_keys = keys.reject { |p| File.exist?(p) }
+      return if stale_keys.empty?
 
       @shared_mutex.synchronize { stale_keys.each { |k| @shared_cache.delete(k) } }
       @new_entries = true

data/app/services/mbeditor/schema_service.rb

@@ -235,10 +235,11 @@ module Mbeditor
     def parse_sql_indexes(content, table_name)
       indexes = []
 
-      # Match CREATE INDEX ... ON table_name (columns)
-      pattern = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+["`]?(\w+)["`]?\s+ON\s+(?:public\.)?["`]?#{Regexp.escape(table_name)}["`]?\s*\((.*?)\)/mi
+      # Match CREATE INDEX ... ON table_name (columns). UNIQUE is captured here
+      # rather than re-scanned per index with a freshly compiled regex.
+      pattern = /CREATE\s+(UNIQUE\s+)?INDEX\s+["`]?(\w+)["`]?\s+ON\s+(?:public\.)?["`]?#{Regexp.escape(table_name)}["`]?\s*\((.*?)\)/mi
 
-      content.scan(pattern) do |index_name, columns_str|
+      content.scan(pattern) do |unique, index_name, columns_str|
         cols = columns_str.split(',').map { |c| c.strip.gsub(/["`]/, '').split(/\s+/).first }.compact
         next if cols.empty?
 
@@ -246,7 +247,7 @@ module Mbeditor
           name: index_name,
           columns: cols
         }
-        idx[:unique] = true if content.match?(/CREATE\s+UNIQUE\s+INDEX\s+["`]?#{Regexp.escape(index_name)}/mi)
+        idx[:unique] = true if unique
 
         indexes << idx
       end
@@ -255,67 +256,67 @@ module Mbeditor
     end
 
     # Map SQL types to Rails column types
-    def sql_type_to_rails(sql_type)
-      type_map = {
-        'integer' => 'integer',
-        'int' => 'integer',
-        'int4' => 'integer',
-        'int2' => 'integer',
-        'int8' => 'bigint',
-        'bigint' => 'bigint',
-        'smallint' => 'integer',
-        'bigserial' => 'bigint',
-        'serial' => 'integer',
-        'varchar' => 'string',
-        'character varying' => 'string',
-        'character' => 'string',
-        'char' => 'string',
-        'text' => 'text',
-        'citext' => 'string',
-        'boolean' => 'boolean',
-        'bool' => 'boolean',
-        'decimal' => 'decimal',
-        'numeric' => 'decimal',
-        'real' => 'float',
-        'float' => 'float',
-        'float4' => 'float',
-        'float8' => 'float',
-        'double precision' => 'float',
-        'double' => 'float',
-        'money' => 'decimal',
-        'timestamp' => 'datetime',
-        'timestamp without time zone' => 'datetime',
-        'timestamp with time zone' => 'datetime',
-        'timestamptz' => 'datetime',
-        'datetime' => 'datetime',
-        'date' => 'date',
-        'time' => 'time',
-        'time without time zone' => 'time',
-        'time with time zone' => 'time',
-        'interval' => 'string',
-        'json' => 'json',
-        'jsonb' => 'jsonb',
-        'uuid' => 'uuid',
-        'bytea' => 'binary',
-        'bit' => 'string',
-        'bit varying' => 'string',
-        'inet' => 'string',
-        'cidr' => 'string',
-        'macaddr' => 'string',
-        'xml' => 'string',
-        'hstore' => 'hstore',
-        'tsvector' => 'string',
-        'ltree' => 'string',
-        'point' => 'string',
-        'line' => 'string',
-        'lseg' => 'string',
-        'box' => 'string',
-        'path' => 'string',
-        'polygon' => 'string',
-        'circle' => 'string'
-      }
+    SQL_TYPE_TO_RAILS = {
+      'integer' => 'integer',
+      'int' => 'integer',
+      'int4' => 'integer',
+      'int2' => 'integer',
+      'int8' => 'bigint',
+      'bigint' => 'bigint',
+      'smallint' => 'integer',
+      'bigserial' => 'bigint',
+      'serial' => 'integer',
+      'varchar' => 'string',
+      'character varying' => 'string',
+      'character' => 'string',
+      'char' => 'string',
+      'text' => 'text',
+      'citext' => 'string',
+      'boolean' => 'boolean',
+      'bool' => 'boolean',
+      'decimal' => 'decimal',
+      'numeric' => 'decimal',
+      'real' => 'float',
+      'float' => 'float',
+      'float4' => 'float',
+      'float8' => 'float',
+      'double precision' => 'float',
+      'double' => 'float',
+      'money' => 'decimal',
+      'timestamp' => 'datetime',
+      'timestamp without time zone' => 'datetime',
+      'timestamp with time zone' => 'datetime',
+      'timestamptz' => 'datetime',
+      'datetime' => 'datetime',
+      'date' => 'date',
+      'time' => 'time',
+      'time without time zone' => 'time',
+      'time with time zone' => 'time',
+      'interval' => 'string',
+      'json' => 'json',
+      'jsonb' => 'jsonb',
+      'uuid' => 'uuid',
+      'bytea' => 'binary',
+      'bit' => 'string',
+      'bit varying' => 'string',
+      'inet' => 'string',
+      'cidr' => 'string',
+      'macaddr' => 'string',
+      'xml' => 'string',
+      'hstore' => 'hstore',
+      'tsvector' => 'string',
+      'ltree' => 'string',
+      'point' => 'string',
+      'line' => 'string',
+      'lseg' => 'string',
+      'box' => 'string',
+      'path' => 'string',
+      'polygon' => 'string',
+      'circle' => 'string'
+    }.freeze
 
-      type_map[sql_type.downcase] || sql_type
+    def sql_type_to_rails(sql_type)
+      SQL_TYPE_TO_RAILS[sql_type.downcase] || sql_type
     end
   end
 end

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
@@ -446,11 +469,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)