mbeditor 0.10.1 → 0.12.0

data/app/services/mbeditor/js_program_service.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Enumerates the workspace's own JavaScript source and hands it to the editor
+  # so Monaco's TypeScript worker can build a real program from it.
+  #
+  # This is the file-based replacement for declaring every discovered name as
+  # ambient `any` (JsGlobalsService). Under Sprockets a JS file with no
+  # import/export is a *script*, so its top-level declarations land in the
+  # global scope — which is exactly TypeScript's own model for script files.
+  # Giving the worker the sources instead of a name list yields real inferred
+  # types, member completions, and argument-count checking, and it still
+  # reports "Cannot find name" for genuinely unknown identifiers.
+  #
+  # What it deliberately does NOT solve: UMD-wrapped libraries. React, lodash
+  # and axios all assign their global inside a closure
+  # (`factory(global.React = {})`), which TypeScript cannot follow statically —
+  # loading their source produces no global at all. Those stay on hand-written
+  # declarations (the React mini-UMD stub) or on JsGlobalsService's ambient
+  # names, which is why that service is still here.
+  #
+  # No truncation: a workspace that exceeds any limit reports what it skipped
+  # and why, rather than silently returning a partial program.
+  class JsProgramService
+    SOURCE_EXT = /\.(js|jsx|ts|tsx)\z/i
+
+    # Minified bundles cost parse time and yield nothing useful — their globals
+    # are one-letter names inside a closure. Matched by convention, then by
+    # shape for bundles whose filename doesn't say so.
+    MINIFIED_NAME = /[.\-]min\.(js|jsx|ts|tsx)\z/i
+    MAX_LINE_LENGTH = 2_000
+
+    # A single source file this large is a bundle or generated output, not
+    # something a person edits.
+    MAX_FILE_BYTES = 1024 * 1024
+
+    CACHE_TTL = 10 # seconds
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    class << self
+      def call(workspace_root)
+        root = File.expand_path(workspace_root.to_s)
+        now  = monotonic
+        MUTEX.synchronize do
+          entry = (@cache ||= {})[root]
+          return entry[:data] if entry && (now - entry[:ts]) < CACHE_TTL
+        end
+
+        data = compute(root)
+        MUTEX.synchronize { (@cache ||= {})[root] = { ts: monotonic, data: data } }
+        data
+      end
+
+      # Content for a single workspace-relative path, for incremental refresh
+      # after a file changes. Returns nil when the path isn't program material.
+      def file(workspace_root, relative_path)
+        root = File.expand_path(workspace_root.to_s)
+        rel  = relative_path.to_s.delete_prefix("/")
+        return nil unless rel.match?(SOURCE_EXT)
+        return nil if rel.match?(MINIFIED_NAME)
+        return nil if matcher(root).excluded?(rel)
+
+        abs = File.expand_path(File.join(root, rel))
+        return nil unless abs == File.join(root, rel) # no traversal out of the workspace
+        return nil unless File.file?(abs) && !File.symlink?(abs)
+
+        content = read_source(abs)
+        content && { path: rel, content: content }
+      end
+
+      def invalidate(workspace_root)
+        MUTEX.synchronize { (@cache ||= {}).delete(File.expand_path(workspace_root.to_s)) }
+      end
+
+      private
+
+      def compute(root)
+        return disabled_result unless Mbeditor.configuration.js_program
+
+        files   = []
+        skipped = []
+        total   = 0
+
+        each_candidate(root) do |rel, abs|
+          if File.size(abs) > MAX_FILE_BYTES
+            skipped << { path: rel, reason: "larger than #{MAX_FILE_BYTES} bytes" }
+            next
+          end
+
+          content = read_source(abs)
+          if content.nil?
+            skipped << { path: rel, reason: "minified or unreadable" }
+            next
+          end
+
+          total += content.bytesize
+          files << { path: rel, content: content }
+        end
+
+        {
+          ok: true,
+          enabled: true,
+          generatedAt: Time.now.to_i,
+          fileCount: files.length,
+          totalBytes: total,
+          skipped: skipped,
+          files: files.sort_by { |f| f[:path] }
+        }
+      end
+
+      def disabled_result
+        { ok: true, enabled: false, generatedAt: Time.now.to_i,
+          fileCount: 0, totalBytes: 0, skipped: [], files: [] }
+      end
+
+      # Walks the workspace, pruning excluded directories before descending so
+      # a node_modules tree is never entered. Symlinks are skipped outright:
+      # this walk is an enumeration, not a resolve_path lookup, and following
+      # them could both escape the workspace and loop.
+      def each_candidate(root)
+        m = matcher(root)
+        stack = [root]
+        while (dir = stack.pop)
+          children(dir).each do |name|
+            abs = File.join(dir, name)
+            rel = abs.delete_prefix(root).delete_prefix("/")
+            next if m.excluded?(rel)
+            next if File.symlink?(abs)
+
+            if File.directory?(abs)
+              stack.push(abs)
+            elsif name.match?(SOURCE_EXT) && !name.match?(MINIFIED_NAME)
+              yield rel, abs
+            end
+          end
+        end
+      end
+
+      def children(dir)
+        Dir.children(dir)
+      rescue SystemCallError
+        []
+      end
+
+      def matcher(root)
+        ExclusionMatcher.new(exclusion_patterns, root: root)
+      end
+
+      def exclusion_patterns
+        Array(Mbeditor.configuration.excluded_paths).map(&:to_s) +
+          Array(Mbeditor.configuration.js_program_exclude).map(&:to_s)
+      end
+
+      # Returns nil for anything that isn't usable program source: unreadable,
+      # invalid encoding, or minified-by-shape (one very long line).
+      def read_source(abs)
+        content = File.read(abs, encoding: Encoding::UTF_8)
+        return nil unless content.valid_encoding?
+        return nil if content.each_line.any? { |line| line.chomp.length > MAX_LINE_LENGTH }
+
+        content
+      rescue SystemCallError, IOError
+        nil
+      end
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/app/services/mbeditor/lsp_diagnostics_translator.rb

@@ -11,24 +11,57 @@ module Mbeditor
     module_function
 
     # LSP DiagnosticSeverity -> the severity strings cop_severity also emits.
-    SEVERITIES = { 1 => "error", 2 => "warning", 3 => "info", 4 => "info" }.freeze
+    # Mirrors ruby-lsp's own RUBOCOP_TO_LSP_SEVERITY in reverse: rubocop's
+    # `info` becomes HINT(4) and convention/refactor become INFORMATION(3), so
+    # the two must map back to distinct editor severities.
+    SEVERITIES = { 1 => "error", 2 => "warning", 3 => "info", 4 => "hint" }.freeze
 
     # ruby-lsp appends this to non-correctable RuboCop messages; it's noise in
     # a Monaco hover.
     UNCORRECTABLE_SUFFIX = "This offense is not auto-correctable."
 
-    def call(result)
+    # Cops whose offense means "this code does nothing" rather than "this code
+    # is wrong". Monaco fades these out (MarkerTag.Unnecessary) instead of
+    # squiggling them, which is the whole point of greying out dead code.
+    #
+    # ruby-lsp emits no DiagnosticTag of its own, so the cop name is the only
+    # signal available — and it's the same signal on the plain-rubocop /lint
+    # path, which is why this predicate is public and shared by both.
+    #
+    # ponytail: name heuristic, not an enumeration. Upgrade path is an explicit
+    # cop list if a badly-named cop ever gets faded by mistake.
+    UNNECESSARY_COP = /Unused|Useless|Redundant|Unreachable|Deprecat/.freeze
+
+    # Prism reports the same dead code as Lint/UselessAssignment and
+    # Lint/UnreachableCode, but as a parser warning with no cop name — so both
+    # markers land on the same range. Fading only the RuboCop one leaves the
+    # Prism squiggle drawn on top and nothing looks greyed out at all.
+    UNNECESSARY_MESSAGE = /\Aassigned but unused variable|\Astatement not reached|\Aunused literal/.freeze
+
+    # Most actions a diagnostic can carry. RuboCop sends two (autocorrect and
+    # disable-for-this-line); the cap is a bound on a payload we don't control.
+    MAX_CODE_ACTIONS = 5
+
+    # Refuse to ship an absurd replacement into the browser. RuboCop's
+    # replacements are a few characters; anything near this is a bug or an
+    # attack, not a quick fix.
+    MAX_EDIT_BYTES = 64 * 1024
+
+    # +uri+ is the request's own document URI. Code actions are only accepted
+    # when every edit they carry targets exactly that document — see
+    # sanitize_code_actions.
+    def call(result, uri = nil)
       items = case result
               when Hash  then Array(result["items"])
               when Array then result
               else []
               end
 
-      markers = items.filter_map { |diag| translate_one(diag) }
+      markers = items.filter_map { |diag| translate_one(diag, uri) }
       { markers: markers, summary: { "offense_count" => markers.length } }
     end
 
-    def translate_one(diag)
+    def translate_one(diag, uri = nil)
       return nil unless diag.is_a?(Hash)
 
       range      = diag["range"] || {}
@@ -41,6 +74,7 @@ module Mbeditor
 
       cop_name = extract_code(diag["code"])
       message  = clean_message(diag["message"])
+      fixes    = sanitize_code_actions(diag, uri)
 
       {
         severity: SEVERITIES.fetch(diag["severity"], "info"),
@@ -53,10 +87,70 @@ module Mbeditor
         source: rubocop_source?(diag["source"]) ? "rubocop" : diag["source"].to_s.downcase,
         message: cop_name.empty? ? message : "[#{cop_name}] #{message}",
         startLine: start_line, startCol: start_col,
-        endLine: end_line, endCol: end_col
+        endLine: end_line, endCol: end_col,
+        unnecessary: unnecessary?(cop_name, message),
+        # RuboCop >= 1.64 ships a docs URL per cop; Monaco renders it as a link
+        # on the marker's code. Absent for non-RuboCop diagnostics.
+        # NB: the LSP wire key is camelCase.
+        codeHref: diag.dig("codeDescription", "href")
+      }.tap { |marker| marker[:fixes] = fixes if fixes.any? }
+    end
+
+    # ruby-lsp embeds the complete edits for each RuboCop fix in the diagnostic
+    # itself. Its textDocument/codeAction handler does nothing but echo these
+    # back (see Requests::CodeActions#perform), so lifting them here lets the
+    # editor apply a fix with no further request at all -- no codeAction call
+    # and no `rubocop -A` subprocess.
+    #
+    # This is a trust boundary: the payload arrives from a subprocess and is
+    # applied to the user's buffer. An action is taken only if every edit in it
+    # targets the very document we asked about.
+    def sanitize_code_actions(diag, uri)
+      return [] if uri.nil?
+
+      Array(diag.dig("data", "code_actions")).first(MAX_CODE_ACTIONS).filter_map do |action|
+        next unless action.is_a?(Hash)
+
+        changes = Array(action.dig("edit", "documentChanges"))
+        next if changes.empty?
+        # Any edit aimed at another file disqualifies the whole action. RuboCop
+        # fixes are always single-file, so this rejects nothing legitimate.
+        next unless changes.all? { |c| c.is_a?(Hash) && c.dig("textDocument", "uri") == uri }
+
+        edits = changes.flat_map { |c| Array(c["edits"]) }.filter_map { |edit| sanitize_edit(edit) }
+        next if edits.empty?
+
+        { title: action["title"].to_s, edits: edits }
+      end
+    end
+
+    # One LSP TextEdit -> the 1-based shape the rest of the marker uses.
+    def sanitize_edit(edit)
+      return nil unless edit.is_a?(Hash)
+
+      text = edit["newText"].to_s
+      return nil if text.bytesize > MAX_EDIT_BYTES
+
+      range = edit["range"]
+      return nil unless range.is_a?(Hash)
+
+      {
+        startLine: (range.dig("start", "line") || 0) + 1,
+        startCol:  (range.dig("start", "character") || 0) + 1,
+        endLine:   (range.dig("end", "line") || range.dig("start", "line") || 0) + 1,
+        endCol:    (range.dig("end", "character") || range.dig("start", "character") || 0) + 1,
+        text: text
       }
     end
 
+    def unnecessary?(cop_name, message = nil)
+      return true if UNNECESSARY_COP.match?(cop_name.to_s)
+
+      # Only consult the message when there is no cop to go on, so a RuboCop
+      # offense is never faded because of a phrase inside its description.
+      cop_name.to_s.empty? && UNNECESSARY_MESSAGE.match?(message.to_s)
+    end
+
     def rubocop_source?(source)
       source.to_s.match?(/rubocop/i)
     end

data/app/services/mbeditor/model_graph_service.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Builds a graph of the host app's ActiveRecord models and the associations
+  # between them, for the Models sidebar tab.
+  #
+  # Reads the associations by *reflection* rather than by parsing model files.
+  # mbeditor already runs inside the host app, so `reflect_on_all_associations`
+  # is right there — and it resolves `class_name:`, `through:`, polymorphic and
+  # inverse sides correctly, which regex or AST parsing of `has_many` lines
+  # silently gets wrong. (ruby-lsp cannot help here: its index models constants
+  # and methods, not associations.)
+  #
+  # Deliberately never touches the database connection. Reflections are pure
+  # metadata, so this works on an app whose database isn't running or migrated;
+  # column counts are only filled in when a connection happens to be live.
+  class ModelGraphService
+    # Rails' own models — ActiveStorage, ActionText, SolidQueue, schema
+    # migrations — are not what you opened this tab to look at.
+    IGNORED_NAMESPACES = %w[
+      ActiveRecord ActiveStorage ActionText ActionMailbox
+      SolidQueue SolidCache SolidCable
+    ].freeze
+
+    MAX_MODELS = 300
+
+    # Only the first few columns travel: the diagram box shows that many and the
+    # full list is a click away in the schema modal, which fetches its own data
+    # from /model_schema.
+    MAX_COLUMNS_SENT = 8
+
+    class << self
+      def call(workspace_root)
+        root = workspace_root.to_s
+        fingerprint = fingerprint_for(root)
+
+        cached = MUTEX.synchronize { @cache }
+        return cached[:payload] if cached && cached[:fingerprint] == fingerprint && cached[:root] == root
+
+        payload = build(root)
+        payload[:fingerprint] = fingerprint
+        MUTEX.synchronize { @cache = { root: root, fingerprint: fingerprint, payload: payload } }
+        write_artifacts(root, payload)
+        payload
+      end
+
+      # Only needed for an explicit refresh: ordinary saves are picked up by
+      # the fingerprint below, so there is no file-change hook to keep in sync.
+      def invalidate(_root = nil)
+        MUTEX.synchronize { @cache = nil }
+        nil
+      end
+
+      # A cheap stand-in for "have the models changed": the newest mtime and the
+      # file count across the model and migration directories. Avoids
+      # eager-loading the app just to decide whether the cache is stale.
+      def fingerprint_for(root)
+        dirs = [File.join(root, "app", "models"), File.join(root, "db", "migrate")]
+        newest = 0
+        count = 0
+        dirs.each do |dir|
+          next unless File.directory?(dir)
+
+          Dir.glob(File.join(dir, "**", "*.rb")).each do |f|
+            count += 1
+            mtime = File.mtime(f).to_i
+            newest = mtime if mtime > newest
+          end
+        end
+        "#{newest}:#{count}"
+      rescue StandardError
+        "unknown"
+      end
+
+      private
+
+      MUTEX = Mutex.new
+      private_constant :MUTEX
+
+      def build(root)
+        unless defined?(::ActiveRecord::Base)
+          return unavailable("This app does not use ActiveRecord, so there are no models to graph.")
+        end
+
+        eager_load!
+        classes = model_classes
+        return unavailable("No ActiveRecord models found in this application.") if classes.empty?
+
+        models = classes.first(MAX_MODELS).map { |klass| describe_model(klass, root) }
+        known = models.map { |m| m[:name] }.to_set
+
+        {
+          ok: true,
+          models: models,
+          # Edges to classes outside the graph (a gem's model, or a typo in
+          # class_name:) would render as arrows into nowhere.
+          edges: models.flat_map { |m| m.delete(:edges) }.select { |e| known.include?(e[:to]) }.uniq,
+          truncated: classes.length > MAX_MODELS,
+          generatedAt: Time.now.utc.iso8601
+        }
+      rescue StandardError => e
+        unavailable("Could not read the model graph: #{e.class}: #{e.message}")
+      end
+
+      def unavailable(message)
+        { ok: false, error: message, models: [], edges: [], generatedAt: Time.now.utc.iso8601 }
+      end
+
+      # In development the host app is lazily loaded, so most models are not
+      # constants yet. This is the one genuinely expensive step.
+      def eager_load!
+        Rails.application.eager_load! if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+      rescue StandardError => e
+        # A model that raises on load shouldn't cost you the whole diagram —
+        # whatever did load is still worth drawing.
+        Rails.logger.warn("[mbeditor] eager_load for the model graph failed: #{e.class}: #{e.message}") if defined?(Rails)
+      end
+
+      def model_classes
+        ::ActiveRecord::Base.descendants.reject do |klass|
+          klass.name.nil? ||
+            klass.abstract_class? ||
+            IGNORED_NAMESPACES.any? { |ns| klass.name.start_with?("#{ns}::") }
+        end.sort_by(&:name)
+      rescue StandardError
+        []
+      end
+
+      def describe_model(klass, root)
+        columns = column_list(klass)
+        {
+          name: klass.name,
+          table: safe(-> { klass.table_name }),
+          columns: columns.first(MAX_COLUMNS_SENT),
+          columnCount: columns.length,
+          superclass: klass.superclass&.name,
+          file: model_file(klass, root),
+          edges: associations_for(klass)
+        }
+      end
+
+      # Needs a live database connection, so it degrades to an empty list rather
+      # than failing: the graph is still worth drawing against a database that
+      # isn't running or migrated.
+      def column_list(klass)
+        klass.columns.map { |c| { name: c.name, type: c.type.to_s } }
+      rescue StandardError
+        []
+      end
+
+      # Where the class was defined, made workspace-relative so the editor can
+      # open it. Models outside the workspace (a gem, or an engine) get no file
+      # and simply aren't clickable.
+      def model_file(klass, root)
+        location = Object.const_source_location(klass.name)
+        path = location && location.first
+        return nil unless path
+
+        prefix = root.end_with?("/") ? root : "#{root}/"
+        path.start_with?(prefix) ? path.delete_prefix(prefix) : nil
+      rescue StandardError
+        nil
+      end
+
+      def associations_for(klass)
+        klass.reflect_on_all_associations.filter_map do |reflection|
+          # A polymorphic belongs_to has no single target class — there is no
+          # edge to draw.
+          next if safe(-> { reflection.polymorphic? })
+
+          target = safe(-> { reflection.class_name })
+          next if target.nil?
+
+          {
+            from: klass.name,
+            to: target,
+            macro: reflection.macro.to_s,
+            name: reflection.name.to_s,
+            through: safe(-> { reflection.options[:through]&.to_s })
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      # Reflection can raise for half-configured associations; one bad
+      # association must not take out the whole graph.
+      def safe(callable)
+        callable.call
+      rescue StandardError
+        nil
+      end
+
+      # The user asked for a file in tmp. The JSON is what the editor reads back
+      # if it wants to; the .mmd is a Mermaid ER diagram that GitHub, VS Code
+      # and mermaid.live all render, for when you want a prettier picture than
+      # the sidebar draws.
+      def write_artifacts(root, payload)
+        dir = File.join(root, "tmp")
+        return unless File.directory?(dir)
+
+        File.write(File.join(dir, "mbeditor_model_graph.json"), JSON.pretty_generate(payload))
+        File.write(File.join(dir, "mbeditor_model_graph.mmd"), to_mermaid(payload))
+      rescue StandardError => e
+        Rails.logger.debug("[mbeditor] could not write model graph artifacts: #{e.message}") if defined?(Rails)
+      end
+
+      MERMAID_CARDINALITY = {
+        "belongs_to" => "}o--||",
+        "has_one" => "||--o|",
+        "has_many" => "||--o{",
+        "has_and_belongs_to_many" => "}o--o{"
+      }.freeze
+
+      def to_mermaid(payload)
+        lines = ["erDiagram"]
+        payload[:models].each { |m| lines << "  #{mermaid_id(m[:name])} {" << "  }" }
+        payload[:edges].each do |e|
+          arrow = MERMAID_CARDINALITY.fetch(e[:macro], "||--||")
+          label = e[:through] ? "#{e[:name]} (through #{e[:through]})" : e[:name]
+          lines << %(  #{mermaid_id(e[:from])} #{arrow} #{mermaid_id(e[:to])} : "#{label}")
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      # Mermaid entity names can't contain ::
+      def mermaid_id(name)
+        name.to_s.gsub("::", "_")
+      end
+    end
+  end
+end

data/app/services/mbeditor/presence_registry.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Who is currently connected for collaborative editing. Thread-safe and
+  # in-memory, modelled on CollaborationDocStore (Mutex + monotonic clock).
+  #
+  # This exists because the clients cannot maintain an accurate roster between
+  # themselves. The original protocol relayed one "here"/"leave" event per
+  # participant and every client merged those into its own roster, which meant a
+  # single dropped or missed message — a peer's browser killed outright, a relay
+  # failure, or simply reloading your own page at the moment someone else closed
+  # theirs — left a participant in your roster permanently, with no expiry to
+  # reclaim it. That is not cosmetic: the roster gates collaboration, so one ghost
+  # kept persistent undo disabled and external on-disk changes suppressed for the
+  # rest of the session, for a peer who was not there.
+  #
+  # The server already knows exactly who is subscribed — Action Cable calls
+  # `unsubscribed` on a clean close and on its own connection timeout — so it is
+  # the only party that can answer this correctly. Every broadcast now carries the
+  # complete roster and clients replace theirs wholesale, so a dropped message
+  # costs one stale interval rather than a permanent phantom. No TTL sweep: an
+  # entry outlives its connection only if the process dies, which takes the
+  # registry with it.
+  module PresenceRegistry
+    module_function
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    # Fields a participant publishes about itself. Anything else in the payload is
+    # dropped — this is relayed to every other client, so the shape is a boundary.
+    # `seq` is the sender's own heartbeat counter, echoed back so they can tell
+    # which broadcast their message caused — every participant's heartbeat now
+    # rebroadcasts everyone, so "my entry came back" alone does not mean "my
+    # message round-tripped", and timing against it inflates the measurement.
+    # `seed` is a stable number derived from the sender's persisted identity. It
+    # exists so a colour clash resolves to the same winner on both sides and stays
+    # resolved across a reload; it is deliberately a hash rather than the id itself.
+    RELAYED_FIELDS = %w[name colour current_file rtt seq seed].freeze
+
+    def record(client_id, attrs, now: monotonic)
+      id = client_id.to_s
+      return if id.empty?
+
+      entry = attrs.slice(*RELAYED_FIELDS)
+      MUTEX.synchronize do
+        participants[id] = entry.merge("client_id" => id, "last_seen" => now)
+      end
+      nil
+    end
+
+    def remove(client_id)
+      id = client_id.to_s
+      MUTEX.synchronize { participants.delete(id) }
+      nil
+    end
+
+    # The full roster, with each entry's idle time resolved against a monotonic
+    # clock here rather than compared across machines — no clock skew to correct.
+    def roster(now: monotonic)
+      MUTEX.synchronize do
+        participants.transform_values do |entry|
+          entry.except("last_seen").merge("idle" => (now - entry["last_seen"]).round)
+        end
+      end
+    end
+
+    def reset!
+      MUTEX.synchronize { @participants = {} }
+      nil
+    end
+
+    def participants
+      @participants ||= {}
+    end
+    private_class_method :participants
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+    private_class_method :monotonic
+  end
+end