mbeditor 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db6694abc38135f7512bba6ce762546b295b079a6e966448a29083b3f5609985
-  data.tar.gz: fa9b0131d5f3309ae5f1f46e837e6bb72c8e378454d4194843b95ba6414e2e00
+  metadata.gz: 07df95cd9d266964f70a477f60b2bf31ae3f1b5f9fd2e24a407cf0ed8b677742
+  data.tar.gz: 2ddf51af23a7fc55466759f8349e0e56dd509777f29ef53653636b81157de562
 SHA512:
-  metadata.gz: 64a1601edc2a1ee6e04854f3a4dff9aeefc400b2d6d91120972514c30a4ed19a7ccd6d44666892bc2043228ac3e48f5ec8096dd2cf620760161927a8ef2a5292
-  data.tar.gz: b6d217f52ab8b0e820d78e43cd51861b4ca86dd02bde6b53f497bd7d743a17b1b405eda0aa540636de4db99b29fdc738322b08271c6093e49d8836eb5b8e76ab
+  metadata.gz: f61404e12d84ebea5e125ab3fd359d802160f8637de8c38256e571d471bfe823d060bb895bbcb495e803de4916bdf0a3e59c974e808fde67d1117a9905ecbea8
+  data.tar.gz: 705206cdada3581c56834307340ce9d184c2a299ed32fa788be97e5067d5fb3b5c0dea01f8fedba7ec1ea070b2c111b47210c1c800f8d7887886d8048eb5dc12

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

@@ -639,7 +639,7 @@ var EditorPanel = function EditorPanel(_ref) {
           if (onSaveRef.current) onSaveRef.current();
         });
         // Wire Ctrl+P to quick-open (VIM intercepts the key before the window listener sees it)
-        MonacoVim.VimMode.Vim.defineEx('mbeditorquickopen', 'mbqo', function() {
+        MonacoVim.VimMode.Vim.defineEx('mbeditorquickopen', null, function() {
           EditorStore.setState({ isQuickOpenVisible: true });
         });
         MonacoVim.VimMode.Vim.map('<C-p>', ':mbeditorquickopen<CR>', 'normal');

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

@@ -695,6 +695,10 @@
     // Ruby method definition hover provider.
     // Calls the backend /definition endpoint (Ripper-based) and renders
     // the method signature and any preceding # comments as hover markdown.
+    // Results are cached client-side for 60 s to make re-hovers instantaneous.
+    var hoverCache = {};
+    var HOVER_CACHE_TTL_MS = 60000;
+
     monaco.languages.registerHoverProvider('ruby', {
       provideHover: function provideHover(model, position, token) {
         var wordInfo = model.getWordAtPosition(position);
@@ -707,51 +711,74 @@
 
         var currentFile = model._mbeditorPath || null;
 
-        return FileService.getDefinition(word, 'ruby').then(function(data) {
+        // Return cached result immediately if still fresh.
+        var cached = hoverCache[word];
+        if (cached && (Date.now() - cached.ts) < HOVER_CACHE_TTL_MS) {
+          var cachedResults = cached.results;
+          if (currentFile) {
+            cachedResults = cachedResults.filter(function(r) { return r.file !== currentFile; });
+          }
+          return cachedResults.length > 0 ? buildHoverResult(cachedResults) : null;
+        }
+
+        // Cancel the underlying HTTP request when Monaco cancels the hover
+        // (e.g. user moved the mouse away before the response arrived).
+        var controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+        if (controller && token && token.onCancellationRequested) {
+          token.onCancellationRequested(function() { controller.abort(); });
+        }
+        var extraOptions = controller ? { signal: controller.signal } : {};
+
+        return FileService.getDefinition(word, 'ruby', extraOptions).then(function(data) {
           // If the hover was cancelled while the request was in flight (e.g. the
           // user moved the mouse away), return null so Monaco's CancelablePromise
           // wrapper resolves cleanly instead of throwing "Canceled".
           if (token && token.isCancellationRequested) return null;
 
           var results = data && Array.isArray(data.results) ? data.results : [];
-          // Filter out results that are in the file currently being edited —
-          // showing a hover for a method you can already see adds no value.
+          // Cache the raw results (before current-file filter).
+          hoverCache[word] = { ts: Date.now(), results: results };
+
           if (currentFile) {
             results = results.filter(function(r) { return r.file !== currentFile; });
           }
           if (results.length === 0) return null;
 
-          var first = results[0];
+          return buildHoverResult(results);
+        }).catch(function() { return null; });
+      }
+    });
+
+    function buildHoverResult(results) {
+      var first = results[0];
 
-          // Build two separate MarkdownString sections so Monaco renders a
-          // visual divider between the code block and the documentation.
-          var codeParts = ['```ruby'];
+      // Build two separate MarkdownString sections so Monaco renders a
+      // visual divider between the code block and the documentation.
+      var codeParts = ['```ruby'];
 
-          // Include a trimmed comment block as a Ruby comment inside the code
-          // fence so the whole thing looks like source you'd read in an editor.
-          if (first.comments && first.comments.length > 0) {
-            first.comments.split('\n').forEach(function(l) {
-              codeParts.push(l.trim() || '#');
-            });
-          }
+      // Include a trimmed comment block as a Ruby comment inside the code
+      // fence so the whole thing looks like source you'd read in an editor.
+      if (first.comments && first.comments.length > 0) {
+        first.comments.split('\n').forEach(function(l) {
+          codeParts.push(l.trim() || '#');
+        });
+      }
 
-          codeParts.push(first.signature);
-          codeParts.push('```');
+      codeParts.push(first.signature);
+      codeParts.push('```');
 
-          var fileRef = first.line > 0 ? first.file + ':' + first.line : first.file;
-          var locationParts = results.length > 1
-            ? fileRef + '  _(+' + (results.length - 1) + ' more)_'
-            : fileRef;
+      var fileRef = first.line > 0 ? first.file + ':' + first.line : first.file;
+      var locationParts = results.length > 1
+        ? fileRef + '  _(+' + (results.length - 1) + ' more)_'
+        : fileRef;
 
-          return {
-            contents: [
-              { value: codeParts.join('\n'), isTrusted: true },
-              { value: '<span style="opacity:0.55;font-size:0.9em;">' + locationParts + '</span>', isTrusted: true, supportHtml: true }
-            ]
-          };
-        }).catch(function() { return null; });
-      }
-    });
+      return {
+        contents: [
+          { value: codeParts.join('\n'), isTrusted: true },
+          { value: '<span style="opacity:0.55;font-size:0.9em;">' + locationParts + '</span>', isTrusted: true, supportHtml: true }
+        ]
+      };
+    }
   }
 
   window.MbeditorEditorPlugins = {

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

@@ -71,8 +71,9 @@ var FileService = (function () {
     return axios.post(basePath() + '/state', { state: state }).then(function(res) { return res.data; });
   }
 
-  function getDefinition(symbol, language) {
-    return axios.get(basePath() + '/definition', { params: { symbol: symbol, language: language } }).then(function(res) { return res.data; });
+  function getDefinition(symbol, language, extraOptions) {
+    var config = Object.assign({ params: { symbol: symbol, language: language }, timeout: 5000 }, extraOptions || {});
+    return axios.get(basePath() + '/definition', config).then(function(res) { return res.data; });
   }
 
   return {

data/app/services/mbeditor/ruby_definition_service.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "find"
+require "json"
 require "ripper"
 
 module Mbeditor
@@ -22,10 +23,72 @@ module Mbeditor
     MAX_RESULTS = 20
     MAX_COMMENT_LOOKAHEAD = 15
 
-    def self.call(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [])
-      new(workspace_root, symbol,
-          excluded_dirnames: excluded_dirnames,
-          excluded_paths: excluded_paths).call
+    # In-process file-index cache.
+    # Structure: { absolute_path => { mtime: Float, lines: [String], all_defs: { method_name => [line, ...] } } }
+    # Protected by a Mutex; entries are invalidated lazily via mtime comparison.
+    # When +cache_path+ is set (done automatically by the engine initializer), the
+    # cache is persisted to disk as JSON so it survives process restarts.
+    @file_cache   = {}
+    @mutex        = Mutex.new
+    @cache_path   = nil
+    @cache_loaded = false
+
+    class << self
+      attr_reader :file_cache, :mutex
+      attr_accessor :cache_path
+
+      def call(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [])
+        new(workspace_root, symbol,
+            excluded_dirnames: excluded_dirnames,
+            excluded_paths: excluded_paths).call
+      end
+
+      # Load the JSON cache from disk exactly once per process (double-checked
+      # under the mutex so concurrent first-calls don't double-load).
+      def load_disk_cache_once
+        return if @cache_loaded
+
+        @mutex.synchronize do
+          return if @cache_loaded
+
+          @cache_loaded = true
+          path = @cache_path.to_s
+          return if path.empty? || !File.exist?(path)
+
+          raw = JSON.parse(File.read(path))
+          raw.each do |abs_path, entry|
+            @file_cache[abs_path] = {
+              mtime:    entry["mtime"].to_f,
+              lines:    entry["lines"],
+              all_defs: entry["all_defs"]
+            }
+          end
+        rescue StandardError
+          nil # corrupted or incompatible cache file — start fresh
+        end
+      end
+
+      # Atomically write the in-memory cache to disk (tmp-file + rename).
+      def persist_cache
+        path = @cache_path.to_s
+        return if path.empty?
+
+        snapshot = @mutex.synchronize { @file_cache.dup }
+        tmp_path = "#{path}.tmp"
+        File.write(tmp_path, JSON.generate(snapshot))
+        File.rename(tmp_path, path)
+      rescue StandardError
+        nil
+      end
+
+      # Exposed for tests.
+      def clear_cache!
+        @mutex.synchronize { @file_cache.clear; @cache_loaded = false }
+        path = @cache_path.to_s
+        File.delete(path) if !path.empty? && File.exist?(path)
+      rescue StandardError
+        nil
+      end
     end
 
     def initialize(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [])
@@ -36,7 +99,10 @@ module Mbeditor
     end
 
     def call
-      results = []
+      self.class.load_disk_cache_once
+
+      results     = []
+      @new_entries = false
 
       Find.find(@workspace_root) do |path|
         # Prune excluded directories
@@ -55,16 +121,18 @@ module Mbeditor
         next if excluded_rel_path?(rel, File.basename(path))
 
         begin
-          source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
-          lines  = source.split("\n", -1)
-          hits   = find_definitions(source, @symbol)
+          cached = cache_entry_for(path)
+          next unless cached
 
-          hits.each do |def_line|
+          hit_lines = cached[:all_defs][@symbol]
+          next unless hit_lines && hit_lines.any?
+
+          hit_lines.each do |def_line|
             results << {
               file:      rel,
               line:      def_line,
-              signature: (lines[def_line - 1] || "").strip,
-              comments:  extract_comments(lines, def_line)
+              signature: (cached[:lines][def_line - 1] || "").strip,
+              comments:  extract_comments(cached[:lines], def_line)
             }
             return results if results.length >= MAX_RESULTS
           end
@@ -73,50 +141,61 @@ module Mbeditor
         end
       end
 
+      self.class.persist_cache if @new_entries
       results
     end
 
     private
 
-    # Parse `source` with Ripper and return sorted array of 1-based line numbers
-    # where a method named `symbol` is defined (handles both `def foo` and `def self.foo`).
-    def find_definitions(source, symbol)
-      sexp = Ripper.sexp(source)
-      return [] unless sexp
+    # Returns the cached index entry for +path+, rebuilding it if the file has
+    # been modified since the last parse.  Returns nil on any read/parse error.
+    def cache_entry_for(path)
+      mtime = File.mtime(path).to_f
+      cached = self.class.mutex.synchronize { self.class.file_cache[path] }
+      return cached if cached && cached[:mtime] == mtime
+
+      source   = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+      lines    = source.split("\n", -1)
+      sexp     = Ripper.sexp(source)
+      all_defs = sexp ? collect_all_defs(sexp) : {}
+      entry    = { mtime: mtime, lines: lines, all_defs: all_defs }
+      self.class.mutex.synchronize { self.class.file_cache[path] = entry }
+      @new_entries = true
+      entry
+    rescue StandardError
+      nil
+    end
 
-      lines = []
-      walk(sexp, symbol, lines)
-      lines.sort
+    # Walk the Ripper sexp once and collect every method definition, returning
+    # a hash of the form { "method_name" => [line_number, ...] }.
+    def collect_all_defs(sexp)
+      defs = Hash.new { |h, k| h[k] = [] }
+      walk_all(sexp, defs)
+      defs
     end
 
-    # Recursive sexp walker.  Ripper represents:
-    #   def foo(...)   as  [:def,  [:@ident, "foo",  [line, col]], ...]
-    #   def self.foo   as  [:defs, receiver, [:@ident, "foo", [line, col]], ...]
-    def walk(node, symbol, lines)
+    def walk_all(node, defs)
       return unless node.is_a?(Array)
 
       case node[0]
       when :def
-        # node[1] is the method name node: [:@ident, "name", [line, col]]
         name_node = node[1]
-        if name_node.is_a?(Array) && name_node[1].to_s == symbol
+        if name_node.is_a?(Array) && name_node[1].is_a?(String)
           line = name_node[2]&.first
-          lines << line if line
+          defs[name_node[1]] << line if line
         end
-        # Still walk children in case of nested defs
-        node[1..].each { |child| walk(child, symbol, lines) }
+        node[1..].each { |child| walk_all(child, defs) }
 
       when :defs
-        # node[3] is the method name node for `def self.foo`
         name_node = node[3]
-        if name_node.is_a?(Array) && name_node[1].to_s == symbol
+        if name_node.is_a?(Array) && name_node[1].is_a?(String)
           line = name_node[2]&.first
-          lines << line if line
+          defs[name_node[1]] << line if line
         end
-        node[1..].each { |child| walk(child, symbol, lines) }
+        node[1..].each { |child| walk_all(child, defs) }
 
       else
-        node.each { |child| walk(child, symbol, lines) }
+        node.each { |child| walk_all(child, defs) }
       end
     end
 

data/lib/mbeditor/engine.rb

@@ -8,6 +8,11 @@ module Mbeditor
       app.middleware.insert_before Rails::Rack::Logger, Mbeditor::Rack::SilencePingRequest
     end
 
+    config.after_initialize do
+      Mbeditor::RubyDefinitionService.cache_path =
+        Rails.root.join("tmp", "mbeditor_ruby_defs.json").to_s
+    end
+
     initializer "mbeditor.assets.precompile" do |app|
       app.config.assets.precompile += %w[
         mbeditor/application.css

data/lib/mbeditor/version.rb

@@ -1,3 +1,3 @@
 module Mbeditor
-  VERSION = "0.2.6"
+  VERSION = "0.2.7"
 end

metadata

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