mbeditor 0.4.4 → 0.5.0

data/app/services/mbeditor/ruby_definition_service.rb

@@ -19,13 +19,26 @@ module Mbeditor
   # Usage:
   #   results = RubyDefinitionService.call(workspace_root, "my_method",
   #                                        excluded_dirnames: %w[tmp .git])
+  #
+  # Additional class methods for IntelliSense features:
+  #   RubyDefinitionService.defs_in_file(abs_path)
+  #     → { "method_name" => [{ line: Integer, signature: String }, ...] }
+  #   RubyDefinitionService.module_defined_in(workspace_root, "ModuleName", ...)
+  #     → abs_path String or nil
+  #   RubyDefinitionService.includes_in_file(abs_path)
+  #     → ["ModuleName", ...]  (include/extend/prepend calls)
   class RubyDefinitionService
     MAX_RESULTS = 20
     MAX_COMMENT_LOOKAHEAD = 15
     MAX_FILES_SCANNED = 10_000
 
     # In-process file-index cache.
-    # Structure: { absolute_path => { mtime: Float, lines: [String], all_defs: { method_name => [line, ...] } } }
+    # Structure: { absolute_path => {
+    #   mtime: Float, lines: [String],
+    #   all_defs: { method_name => [line, ...] },
+    #   module_names: [String],    # module/class names defined in the file
+    #   include_calls: [String]    # module names passed to include/extend/prepend
+    # } }
     # 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.
@@ -59,9 +72,11 @@ module Mbeditor
           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"]
+              mtime:         entry["mtime"].to_f,
+              lines:         entry["lines"],
+              all_defs:      entry["all_defs"],
+              module_names:  entry["module_names"],   # nil for old-format entries → triggers re-parse
+              include_calls: entry["include_calls"]   # nil for old-format entries → triggers re-parse
             }
           end
         rescue StandardError
@@ -90,6 +105,59 @@ module Mbeditor
       rescue StandardError
         nil
       end
+
+      # Returns all method defs in a single file from the cache (no workspace walk).
+      # The file must already be cached; returns {} if not found.
+      # Result: { "method_name" => [{ line: Integer, signature: String }, ...] }
+      def defs_in_file(file_path)
+        load_disk_cache_once
+        entry = @mutex.synchronize { @file_cache[file_path.to_s] }
+        return {} unless entry
+
+        entry[:all_defs].transform_values do |lines_arr|
+          lines_arr.map { |line| { line: line, signature: (entry[:lines][line - 1] || "").strip } }
+        end
+      end
+
+      # Searches the cache (and triggers a workspace scan if needed) to find
+      # which file in +workspace_root+ defines the given module or class name.
+      # Returns the absolute file path string or nil.
+      def module_defined_in(workspace_root, module_name, excluded_dirnames: [], excluded_paths: [])
+        load_disk_cache_once
+        result = @mutex.synchronize do
+          @file_cache.find { |_path, entry| entry[:module_names]&.include?(module_name) }
+        end
+        return result[0] if result
+
+        # Cache miss: scan workspace to populate cache entries with module_names.
+        new(workspace_root, nil,
+            excluded_dirnames: excluded_dirnames,
+            excluded_paths:    excluded_paths).scan_workspace
+
+        result = @mutex.synchronize do
+          @file_cache.find { |_path, entry| entry[:module_names]&.include?(module_name) }
+        end
+        result ? result[0] : nil
+      end
+
+      # Returns the list of module/class names passed to include/extend/prepend
+      # in the given file, from the cache.  The file must already be cached;
+      # returns [] if not found.
+      def includes_in_file(file_path)
+        load_disk_cache_once
+        entry = @mutex.synchronize { @file_cache[file_path.to_s] }
+        return [] unless entry
+
+        entry[:include_calls] || []
+      end
+
+      # Convenience wrapper: scan the whole workspace to warm the cache.
+      # Fast on subsequent calls (only re-parses files whose mtime changed).
+      def scan(workspace_root, excluded_dirnames: [], excluded_paths: [])
+        new(workspace_root, nil,
+            excluded_dirnames: excluded_dirnames,
+            excluded_paths:    excluded_paths).scan_workspace
+      end
     end
 
     def initialize(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [])
@@ -99,6 +167,42 @@ module Mbeditor
       @excluded_paths    = Array(excluded_paths)
     end
 
+    # Walks the entire workspace and populates the per-file cache (including the
+    # new module_names and include_calls fields) without filtering by symbol.
+    # Used by +module_defined_in+ to ensure the cache is warm.
+    def scan_workspace
+      self.class.load_disk_cache_once
+      @new_entries  = false
+      files_scanned = 0
+      evict_deleted_cache_entries
+
+      Find.find(@workspace_root) do |path|
+        if File.directory?(path)
+          dirname = File.basename(path)
+          rel_dir = relative_path(path)
+          Find.prune if path != @workspace_root && excluded_dir?(dirname, rel_dir)
+          next
+        end
+        next unless path.end_with?(".rb")
+
+        rel = relative_path(path)
+        next if excluded_rel_path?(rel, File.basename(path))
+
+        files_scanned += 1
+        if files_scanned > MAX_FILES_SCANNED
+          Rails.logger.warn("[mbeditor] RubyDefinitionService: workspace exceeds #{MAX_FILES_SCANNED} .rb files; stopping scan early")
+          break
+        end
+        begin
+          cache_entry_for(path)
+        rescue StandardError
+          nil
+        end
+      end
+
+      self.class.persist_cache if @new_entries
+    end
+
     def call
       self.class.load_disk_cache_once
 
@@ -134,7 +238,7 @@ module Mbeditor
           cached = cache_entry_for(path)
           next unless cached
 
-          hit_lines = cached[:all_defs][@symbol]
+          hit_lines = @symbol ? cached[:all_defs].fetch(@symbol, nil) : nil
           next unless hit_lines && hit_lines.any?
 
           hit_lines.each do |def_line|
@@ -173,13 +277,14 @@ module Mbeditor
     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 }
+      return cached if cached && cached[:mtime] == mtime && !cached[:module_names].nil?
+
+      source                              = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+      lines                               = source.split("\n", -1)
+      sexp                                = Ripper.sexp(source)
+      all_defs, module_names, include_calls = sexp ? collect_all_defs(sexp) : [{}, [], []]
+      entry = { mtime: mtime, lines: lines, all_defs: all_defs,
+                module_names: module_names, include_calls: include_calls }
       self.class.mutex.synchronize { self.class.file_cache[path] = entry }
       @new_entries = true
       entry
@@ -187,15 +292,18 @@ module Mbeditor
       nil
     end
 
-    # Walk the Ripper sexp once and collect every method definition, returning
-    # a hash of the form { "method_name" => [line_number, ...] }.
+    # Walk the Ripper sexp once and collect method definitions, module/class names,
+    # and include/extend/prepend calls.
+    # Returns [defs_hash, module_names_array, include_calls_array].
     def collect_all_defs(sexp)
-      defs = Hash.new { |h, k| h[k] = [] }
-      walk_all(sexp, defs)
-      defs
+      defs          = Hash.new { |h, k| h[k] = [] }
+      module_names  = []
+      include_calls = []
+      walk_all(sexp, defs, module_names, include_calls)
+      [defs, module_names, include_calls]
     end
 
-    def walk_all(node, defs)
+    def walk_all(node, defs, module_names, include_calls)
       return unless node.is_a?(Array)
 
       case node[0]
@@ -205,7 +313,7 @@ module Mbeditor
           line = name_node[2]&.first
           defs[name_node[1]] << line if line
         end
-        node[1..].each { |child| walk_all(child, defs) }
+        node[1..].each { |child| walk_all(child, defs, module_names, include_calls) }
 
       when :defs
         name_node = node[3]
@@ -213,10 +321,44 @@ module Mbeditor
           line = name_node[2]&.first
           defs[name_node[1]] << line if line
         end
-        node[1..].each { |child| walk_all(child, defs) }
+        node[1..].each { |child| walk_all(child, defs, module_names, include_calls) }
+
+      when :module, :class
+        # Collect the module/class constant name.
+        # sexp: [:module, [:const_ref, [:@const, "Name", [line, col]]], body]
+        #   or: [:class,  [:const_ref, [:@const, "Name", [line, col]]], superclass, body]
+        const_ref = node[1]
+        if const_ref.is_a?(Array)
+          inner = const_ref[0] == :const_ref ? const_ref[1] : const_ref
+          if inner.is_a?(Array) && inner[0] == :@const && inner[1].is_a?(String)
+            module_names << inner[1]
+          end
+        end
+        node[1..].each { |child| walk_all(child, defs, module_names, include_calls) }
+
+      when :command
+        # Collect include/extend/prepend calls.
+        # sexp: [:command, [:@ident, "include", [line, col]],
+        #          [:args_add_block, [[:var_ref, [:@const, "Name", ...]], ...], false]]
+        ident_node = node[1]
+        if ident_node.is_a?(Array) && ident_node[0] == :@ident &&
+           %w[include extend prepend].include?(ident_node[1])
+          args_node = node[2]
+          if args_node.is_a?(Array) && args_node[0] == :args_add_block
+            Array(args_node[1]).each do |arg|
+              if arg.is_a?(Array) && arg[0] == :var_ref
+                const_node = arg[1]
+                if const_node.is_a?(Array) && const_node[0] == :@const && const_node[1].is_a?(String)
+                  include_calls << const_node[1]
+                end
+              end
+            end
+          end
+        end
+        node[1..].each { |child| walk_all(child, defs, module_names, include_calls) }
 
       else
-        node.each { |child| walk_all(child, defs) }
+        node.each { |child| walk_all(child, defs, module_names, include_calls) }
       end
     end
 

data/app/services/mbeditor/unused_methods_service.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Mbeditor
+  # Finds method definitions in a file that have no call-sites anywhere in the
+  # workspace.  Uses a single ripgrep (or grep) subprocess with an alternation
+  # pattern so cost is O(1) subprocesses regardless of how many methods the
+  # file contains.
+  #
+  # Results are cached per-file; entries are invalidated when the file's mtime
+  # changes OR when the entry is older than CACHE_TTL_SECONDS (handles edits
+  # to other files that may add or remove call-sites).
+  #
+  # Usage:
+  #   UnusedMethodsService.call(workspace_root, abs_path,
+  #                             excluded_dirnames: [], excluded_paths: [])
+  #   → [{ name: "my_method", line: 42 }, ...]
+  class UnusedMethodsService
+    CACHE_TTL_SECONDS = 30
+    RG_TIMEOUT        = 10
+    GREP_TIMEOUT      = 30
+
+    @cache       = {}
+    @cache_mutex = Mutex.new
+
+    class << self
+      def call(workspace_root, file_path, excluded_dirnames: [], excluded_paths: [])
+        file_path = file_path.to_s
+
+        begin
+          mtime = File.mtime(file_path).to_f
+        rescue StandardError
+          return []
+        end
+
+        # Return cached result if file mtime matches and the entry is fresh.
+        cached = @cache_mutex.synchronize { @cache[file_path] }
+        if cached && cached[:mtime] == mtime &&
+           (Process.clock_gettime(Process::CLOCK_MONOTONIC) - cached[:ts]) < CACHE_TTL_SECONDS
+          return cached[:result]
+        end
+
+        # Ensure the file is indexed (populates module_names / include_calls too).
+        defs = RubyDefinitionService.defs_in_file(file_path)
+        if defs.empty?
+          # File not yet in cache; trigger a parse of just this one file by
+          # calling the definition service with a dummy symbol.
+          RubyDefinitionService.call(workspace_root, "__mbeditor_warmup__",
+                                     excluded_dirnames: excluded_dirnames,
+                                     excluded_paths:    excluded_paths)
+          defs = RubyDefinitionService.defs_in_file(file_path)
+        end
+        return [] if defs.empty?
+
+        method_names = defs.keys
+        counts       = count_occurrences(method_names, workspace_root.to_s,
+                                         excluded_dirnames: excluded_dirnames,
+                                         excluded_paths:    excluded_paths)
+
+        # A method with ≤1 total occurrence has only its own `def` line; no call-sites.
+        unused = method_names.select { |n| counts.fetch(n, 0) <= 1 }
+        result = unused.filter_map do |name|
+          entries = defs[name]
+          next unless entries&.any?
+          { name: name, line: entries.first[:line] }
+        end
+
+        ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @cache_mutex.synchronize do
+          @cache[file_path] = { mtime: mtime, ts: ts, result: result }
+        end
+
+        result
+      rescue StandardError
+        []
+      end
+
+      # Exposed for tests.
+      def clear_cache!
+        @cache_mutex.synchronize { @cache.clear }
+      end
+
+      private
+
+      RG_AVAILABLE = system("which rg > /dev/null 2>&1")
+
+      def count_occurrences(method_names, workspace_root, excluded_dirnames:, excluded_paths:)
+        # Build one alternation pattern matching any of the method names as
+        # whole identifiers.  We escape each name and join with |.
+        escaped  = method_names.map { |n| Regexp.escape(n) }
+        pattern  = "\\b(#{escaped.join('|')})\\b"
+
+        if RG_AVAILABLE
+          run_ripgrep(pattern, method_names, workspace_root, excluded_paths)
+        else
+          run_grep(pattern, method_names, workspace_root, excluded_dirnames)
+        end
+      end
+
+      # ripgrep: --only-matching outputs one match per line (just the matched text).
+      def run_ripgrep(pattern, method_names, workspace_root, excluded_paths)
+        args = %w[rg --only-matching --no-filename --no-ignore --glob **/*.rb]
+        excluded_paths.each { |p| args += ["--glob", "!#{p}"] }
+        args += ["-e", pattern, workspace_root]
+
+        counts = Hash.new(0)
+        name_set = method_names.to_set
+        Timeout.timeout(RG_TIMEOUT) do
+          IO.popen(args, err: File::NULL) do |io|
+            io.each_line { |line| name = line.chomp; counts[name] += 1 if name_set.include?(name) }
+          end
+        end
+        counts
+      rescue StandardError
+        {}
+      end
+
+      # grep -oh: -o outputs only the matching part, -h suppresses filenames.
+      def run_grep(pattern, method_names, workspace_root, excluded_dirnames)
+        args = ["grep", "-roh", "-E", pattern, "--include=*.rb"]
+        excluded_dirnames.each { |d| args += ["--exclude-dir=#{d}"] }
+        args << workspace_root
+
+        counts = Hash.new(0)
+        name_set = method_names.to_set
+        Timeout.timeout(GREP_TIMEOUT) do
+          IO.popen(args, err: File::NULL) do |io|
+            io.each_line { |line| name = line.chomp; counts[name] += 1 if name_set.include?(name) }
+          end
+        end
+        counts
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/app/views/layouts/mbeditor/application.html.erb

@@ -69,11 +69,16 @@
       }
     };
 
-    // Load Prettier scripts in parallel with define temporarily hidden so their
-    // UMD wrapper sets window.prettier / window.prettierPlugins instead of
-    // registering as AMD modules via Monaco's loader.  Then load Monaco and the
-    // app once all Prettier scripts are ready.
+    // Hide window.define before deferred vendor scripts (React, ReactDOM, etc.) execute
+    // so their UMD wrappers set window globals instead of registering as AMD modules.
+    // Prettier is loaded lazily on first Format action via window.loadPrettierPlugins().
     (function() {
+      var _define = window.define;
+      window.define = undefined;
+
+      // Expose lazy Prettier loader — called on first Format action.
+      // Temporarily hides window.define so Prettier's UMD wrapper sets
+      // window.prettier / window.prettierPlugins instead of using AMD.
       var prettierScripts = [
         '<%= asset_path("prettier-standalone.js") %>',
         '<%= asset_path("prettier-plugin-babel.js") %>',
@@ -83,64 +88,89 @@
         '<%= asset_path("prettier-plugin-markdown.js") %>'
       ];
 
-      var _define = window.define;
-      window.define = undefined;
-      var pending = prettierScripts.length;
-
-      function onAllPrettierLoaded() {
-        // Deferred vendor scripts (React, ReactDOM, etc.) run before DOMContentLoaded.
-        // Restoring window.define before they execute would cause them to register
-        // as AMD modules instead of setting window globals, so wait for DOMContentLoaded first.
-        function proceed() {
-          // Store mbeditor's React/ReactDOM under a private namespace so the
-          // app bundle can use them without touching window.React / window.ReactDOM.
-          window.MbeditorRuntime = {
-            React:    window.React,
-            ReactDOM: window.ReactDOM
-          };
-          // Restore whatever the host app had before our deferred scripts ran.
-          window.React    = window._mbeditorHostReact;
-          window.ReactDOM = window._mbeditorHostReactDOM;
-
-          window.define = _define;
-
-          // Wait for Monaco to load before initializing application scripts
-          require(['vs/editor/editor.main'], function() {
-            // Register custom themes from the vendored bundle
-            if (window.MBEDITOR_CUSTOM_THEMES && window.monaco) {
-              Object.keys(window.MBEDITOR_CUSTOM_THEMES).forEach(function(id) {
-                window.monaco.editor.defineTheme(id, window.MBEDITOR_CUSTOM_THEMES[id]);
-              });
-            }
-            var appScript = document.createElement('script');
-            appScript.src = '<%= asset_path("mbeditor/application.js") %>';
-            appScript.onload = function() {
-              var root = document.getElementById('mbeditor-root');
-              var _R  = window.MbeditorRuntime.React;
-              var _RD = window.MbeditorRuntime.ReactDOM;
-              if (window.MbeditorApp && _R && _RD) {
-                _RD.render(_R.createElement(window.MbeditorApp), root);
-              } else {
-                console.error("Failed to mount: MbeditorApp or MbeditorRuntime is undefined.");
+      window.loadPrettierPlugins = function() {
+        if (window._prettierLoadPromise) return window._prettierLoadPromise;
+        window._prettierLoadPromise = new Promise(function(resolve, reject) {
+          var savedDefine = window.define;
+          window.define = undefined;
+          var pending = prettierScripts.length;
+          prettierScripts.forEach(function(src) {
+            var s = document.createElement('script');
+            s.src = src;
+            s.onload = function() {
+              if (--pending === 0) {
+                window.define = savedDefine;
+                resolve();
               }
             };
-            document.body.appendChild(appScript);
+            s.onerror = function() {
+              window.define = savedDefine;
+              reject(new Error('Failed to load Prettier: ' + src));
+            };
+            document.head.appendChild(s);
           });
-        }
+        });
+        return window._prettierLoadPromise;
+      };
 
-        if (window._mbeditorDOMReady) {
-          proceed();
-        } else {
-          document.addEventListener('DOMContentLoaded', proceed, { once: true });
-        }
+      // Deferred vendor scripts (React, ReactDOM, etc.) run before DOMContentLoaded.
+      // Restoring window.define before they execute would cause them to register
+      // as AMD modules instead of setting window globals, so wait for DOMContentLoaded first.
+      function proceed() {
+        // Store mbeditor's React/ReactDOM under a private namespace so the
+        // app bundle can use them without touching window.React / window.ReactDOM.
+        window.MbeditorRuntime = {
+          React:    window.React,
+          ReactDOM: window.ReactDOM
+        };
+        // Restore whatever the host app had before our deferred scripts ran.
+        window.React    = window._mbeditorHostReact;
+        window.ReactDOM = window._mbeditorHostReactDOM;
+
+        window.define = _define;
+
+        // Expose a promise that resolves when Monaco finishes loading.
+        // EditorPanel awaits this before calling monaco.editor.create().
+        var _monacoResolve;
+        window.__monacoReady = new Promise(function(resolve) { _monacoResolve = resolve; });
+
+        // Load application.js immediately — React mounts before Monaco is ready.
+        // EditorPanel will show a skeleton until window.__monacoReady resolves.
+        var appScript = document.createElement('script');
+        appScript.src = '<%= asset_path("mbeditor/application.js") %>';
+        appScript.onload = function() {
+          var root = document.getElementById('mbeditor-root');
+          var _R  = window.MbeditorRuntime.React;
+          var _RD = window.MbeditorRuntime.ReactDOM;
+          if (window.MbeditorApp && _R && _RD) {
+            _RD.render(_R.createElement(window.MbeditorApp), root);
+          } else {
+            console.error("Failed to mount: MbeditorApp or MbeditorRuntime is undefined.");
+          }
+        };
+        appScript.onerror = function() {
+          console.error('Mbeditor: failed to load application.js');
+          document.getElementById('mbeditor-root').innerHTML = '<div style="padding:2rem;font-family:sans-serif;color:#c00">Editor failed to load. Please refresh the page.</div>';
+        };
+        document.body.appendChild(appScript);
+
+        // Load Monaco in parallel — resolves the promise when done.
+        require(['vs/editor/editor.main'], function() {
+          // Register custom themes from the vendored bundle
+          if (window.MBEDITOR_CUSTOM_THEMES && window.monaco) {
+            Object.keys(window.MBEDITOR_CUSTOM_THEMES).forEach(function(id) {
+              window.monaco.editor.defineTheme(id, window.MBEDITOR_CUSTOM_THEMES[id]);
+            });
+          }
+          _monacoResolve();
+        });
       }
 
-      prettierScripts.forEach(function(src) {
-        var s = document.createElement('script');
-        s.src = src;
-        s.onload = function() { if (--pending === 0) onAllPrettierLoaded(); };
-        document.head.appendChild(s);
-      });
+      if (window._mbeditorDOMReady) {
+        proceed();
+      } else {
+        document.addEventListener('DOMContentLoaded', proceed, { once: true });
+      }
     })();
   </script>
 </body>

data/config/routes.rb

@@ -19,7 +19,11 @@ Mbeditor::Engine.routes.draw do
   post   'branch_state',    to: 'editors#save_branch_state'
   post   'prune_branch_states', to: 'editors#prune_branch_states'
   get    'search',          to: 'editors#search'
+  post   'replace_in_files', to: 'editors#replace_in_files'
   get    'definition',      to: 'editors#definition'
+  get    'module_members',  to: 'editors#module_members'
+  get    'file_includes',   to: 'editors#file_includes'
+  get    'unused_methods',  to: 'editors#unused_methods'
   get    'git_info',        to: 'editors#git_info'
   get    'git_status',      to: 'editors#git_status'
   get    'manifest.webmanifest',            to: 'editors#pwa_manifest',   format: false

data/lib/mbeditor/cable_log_filter.rb

@@ -9,6 +9,7 @@ module Mbeditor
   # Non-Mbeditor ActionCable messages pass through unchanged.
   class CableLogFilter < SimpleDelegator
     SUPPRESS_PATTERN = /Mbeditor::|mbeditor_editor/
+    CABLE_WEBSOCKET_REQUEST_PATTERN = /(?:Started|Finished) "\/cable(?:\/[^\"]*)?" \[WebSocket\]/
 
     # Provides no-op tagged logging APIs for plain Ruby formatters.
     class UntaggedFormatter < SimpleDelegator
@@ -57,12 +58,16 @@ 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 msg.match?(SUPPRESS_PATTERN)
+        return if suppress_message?(msg)
 
         super(message, &block)
       end
     end
 
+    def suppress_message?(message)
+      message.match?(SUPPRESS_PATTERN) || message.match?(CABLE_WEBSOCKET_REQUEST_PATTERN)
+    end
+
     # Tagged-logging compat — the block body still passes through the filter.
     def tagged(*tags, &block)
       if __getobj__.respond_to?(:tagged)

data/lib/mbeditor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mbeditor
-  VERSION = "0.4.4"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Oliver Noonan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -95,6 +95,7 @@ files:
 - app/services/mbeditor/ri_definition_service.rb
 - app/services/mbeditor/ruby_definition_service.rb
 - app/services/mbeditor/test_runner_service.rb
+- app/services/mbeditor/unused_methods_service.rb
 - app/views/layouts/mbeditor/application.html.erb
 - app/views/mbeditor/editors/index.html.erb
 - config/initializers/assets.rb