ruby-lsp-refactor 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e93bae39d557e3ff626edb5cd4465bb6ad637011f806b36900063777879f9e5d
-  data.tar.gz: a9f97f89abb0fa58a65d3fce8e451f9ee74a78bf1249f8d22045b1dffd18953b
+  metadata.gz: 8b5c862a6cc032cef40f72215c0dd23fdf603dfac480f06d40dbcb44aaf90b70
+  data.tar.gz: e54a99c4047ca609133ffa416bb48b03764404a88582268c7a02c31c0d22fb5d
 SHA512:
-  metadata.gz: b1ae08611fbb7d89e77fd5bad6111889317d158a79f7e1bf47d3acc229e6ed3b58c6a8ff2059359d71d614ea95b742ab40f22db7e610e36b2d3b15e9345c24a0
-  data.tar.gz: 8afd108cdaa93c2a8c17fa9ab123da4a117254d71e7044f3b2ce1f21c2649d4a3d5fc57c690be34fd1ee629b2b2d961f1157bf814c90ec4c0f0b9ff82c121fc6
+  metadata.gz: 42ae1d9fdb145a816069ab5aed98e2b3dd5167dabcc8e980a74d3658d8eb4ae8a6fc78a5d6e2a5db1312b08ad19f245b7d049057eb7cab8254276dab60b6e43a
+  data.tar.gz: 552ac629c91808223461f1ff6ac3ed806815dc1a11895ad041f728b144828f35fd9470e67c8a7c6e1f5349bf0ea86848d2b28be33ac2d17d66d0dc1a817cbb15

data/.rubocop_todo.yml

@@ -0,0 +1,68 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2026-06-15 16:00:25 UTC using RuboCop version 1.87.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 19
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 42
+
+# Offense count: 4
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ClassLength:
+  Max: 218
+
+# Offense count: 5
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/CyclomaticComplexity:
+  Max: 11
+
+# Offense count: 42
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 36
+
+# Offense count: 4
+# Configuration parameters: AllowedMethods, AllowedPatterns.
+Metrics/PerceivedComplexity:
+  Max: 11
+
+# Offense count: 2
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
+Naming/MethodParameterName:
+  Exclude:
+    - 'lib/ruby_lsp/ruby_lsp_refactor/listeners/hash_listener.rb'
+
+# Offense count: 3
+# Configuration parameters: NamePrefix, ForbiddenPrefixes, AllowedMethods, MethodDefinitionMacros, UseSorbetSigs.
+# NamePrefix: is_, has_, have_, does_
+# ForbiddenPrefixes: is_, has_, have_, does_
+# AllowedMethods: is_a?
+# MethodDefinitionMacros: define_method, define_singleton_method
+Naming/PredicatePrefix:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/ruby_lsp/ruby_lsp_refactor/listeners/hash_listener.rb'
+    - 'lib/ruby_lsp/ruby_lsp_refactor/listeners/method_listener.rb'
+    - 'lib/ruby_lsp/ruby_lsp_refactor/listeners/super_listener.rb'
+
+# Offense count: 1
+# Configuration parameters: EnforcedStyle, CheckMethodNames, CheckSymbols, AllowedIdentifiers, AllowedPatterns.
+# SupportedStyles: snake_case, normalcase, non_integer
+# AllowedIdentifiers: TLS1_1, TLS1_2, capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339, x86_64
+Naming/VariableNumber:
+  Exclude:
+    - 'test/ruby_lsp_refactor/enumerable_listener_test.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/ruby_lsp/ruby_lsp_refactor/addon.rb'

data/lib/ruby/lsp/refactor/version.rb

@@ -3,7 +3,7 @@
 module Ruby
   module Lsp
     module Refactor
-      VERSION = "0.1.0"
+      VERSION = "0.1.1"
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_refactor/addon.rb

@@ -1,14 +1,29 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/addon"
-require "ruby_lsp/requests/code_actions"
-require "ruby_lsp/requests/code_action_resolve"
+
+# Phase 1 – Local rewrites
 require_relative "listeners/conditional_listener"
-require_relative "listeners/variable_listener"
 require_relative "listeners/string_listener"
+require_relative "listeners/block_style_listener"
+require_relative "listeners/logical_operator_listener"
+
+# Phase 2 – Variable & literal optimisation
+require_relative "listeners/variable_listener"
 require_relative "listeners/hash_listener"
 require_relative "listeners/array_listener"
+require_relative "listeners/string_array_listener"
+require_relative "listeners/string_freeze_listener"
+require_relative "listeners/enumerable_listener"
+require_relative "listeners/raise_listener"
+
+# Phase 3 – Advanced structure
 require_relative "listeners/method_listener"
+require_relative "listeners/constant_listener"
+require_relative "listeners/accessor_listener"
+require_relative "listeners/rescue_listener"
+require_relative "listeners/super_listener"
+require_relative "listeners/rspec_let_listener"
 
 module RubyLsp
   module Refactor
@@ -31,7 +46,7 @@ module RubyLsp
 
     class Addon < ::RubyLsp::Addon
       # Called once when the language server activates this add-on.
-      def activate(global_state, message_queue)
+      def activate(global_state, _message_queue)
         @global_state = global_state
 
         # Inject our actions into the standard code-actions response.
@@ -62,13 +77,13 @@ module RubyLsp
 
         cursor_range = Interface::Range.new(
           start: Interface::Position.new(
-            line:      range.dig(:start, :line),
-            character: range.dig(:start, :character),
+            line: range.dig(:start, :line),
+            character: range.dig(:start, :character)
           ),
           end: Interface::Position.new(
-            line:      range.dig(:end, :line),
-            character: range.dig(:end, :character),
-          ),
+            line: range.dig(:end, :line),
+            character: range.dig(:end, :character)
+          )
         )
 
         node_context     = NodeContext.new(document.uri.to_s, cursor_range)
@@ -78,14 +93,25 @@ module RubyLsp
         # Phase 1 – Local rewrites
         ConditionalListener.new(response_builder, node_context, dispatcher)
         StringListener.new(response_builder, node_context, dispatcher)
+        BlockStyleListener.new(response_builder, node_context, dispatcher)
+        LogicalOperatorListener.new(response_builder, node_context, dispatcher)
 
         # Phase 2 – Variable & literal optimisation
         VariableListener.new(response_builder, node_context, dispatcher)
         HashListener.new(response_builder, node_context, dispatcher)
         ArrayListener.new(response_builder, node_context, dispatcher)
+        StringArrayListener.new(response_builder, node_context, dispatcher)
+        StringFreezeListener.new(response_builder, node_context, dispatcher)
+        EnumerableListener.new(response_builder, node_context, dispatcher)
+        RaiseListener.new(response_builder, node_context, dispatcher)
 
         # Phase 3 – Advanced structure
         MethodListener.new(response_builder, node_context, dispatcher)
+        ConstantListener.new(response_builder, node_context, dispatcher)
+        AccessorListener.new(response_builder, node_context, dispatcher)
+        RescueListener.new(response_builder, node_context, dispatcher)
+        SuperListener.new(response_builder, node_context, dispatcher)
+        RspecLetListener.new(response_builder, node_context, dispatcher)
 
         dispatcher.dispatch(document.ast)
         response_builder.response

data/lib/ruby_lsp/ruby_lsp_refactor/listeners/accessor_listener.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Detects an `attr_reader :name` paired with a canonical manual writer
+    # `def name=(val); @name = val; end` in the same class body and offers
+    # to collapse them into a single `attr_accessor :name`.
+    #
+    # Input (cursor on either the attr_reader or the writer def):
+    #   attr_reader :name
+    #   def name=(val)
+    #     @name = val
+    #   end
+    #
+    # Output:
+    #   attr_accessor :name
+    #
+    # The manual writer is considered canonical when its body contains exactly
+    # one statement of the form `@name = val` where `val` is the sole parameter.
+    class AccessorListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        # Collect attr_reader calls and writer defs within the same class body.
+        @attr_readers = []  # [{ name:, node: }]
+        @writer_defs  = []  # [{ name:, node: }]
+        @class_depth  = 0
+
+        dispatcher.register(
+          self,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_call_node_enter,
+          :on_def_node_enter
+        )
+      end
+
+      def on_class_node_enter(_node)
+        @class_depth += 1
+      end
+
+      def on_class_node_leave(_node)
+        @class_depth -= 1
+        # Emit any matched pairs before clearing — on_program_node_leave fires
+        # after on_class_node_leave, so we must act here while data is present.
+        emit_matching_pairs
+        @attr_readers.clear
+        @writer_defs.clear
+      end
+
+      def on_call_node_enter(node)
+        return unless @class_depth.positive?
+        return unless node.name == :attr_reader
+        return unless node.arguments
+
+        node.arguments.arguments.each do |arg|
+          next unless arg.is_a?(Prism::SymbolNode)
+
+          @attr_readers << { name: arg.unescaped.to_sym, node: node, sym_node: arg }
+        end
+      rescue StandardError
+        nil
+      end
+
+      def on_def_node_enter(node)
+        return unless @class_depth.positive?
+        return unless node.name.to_s.end_with?("=")
+
+        attr_name = node.name.to_s.delete_suffix("=").to_sym
+        return unless canonical_writer?(node, attr_name)
+
+        @writer_defs << { name: attr_name, node: node }
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Match readers with writers and emit actions for any pair where the
+      # cursor falls on either node.
+      def emit_matching_pairs
+        @attr_readers.each do |reader|
+          writer = @writer_defs.find { |w| w[:name] == reader[:name] }
+          next unless writer
+
+          next unless node_covers_cursor?(reader[:node]) ||
+                      node_covers_cursor?(writer[:node])
+
+          emit_collapse(reader, writer)
+        end
+      rescue StandardError
+        nil
+      end
+
+      # A writer def is canonical when:
+      #   1. It has exactly one required parameter.
+      #   2. Its body is exactly one statement: `@name = <param>`.
+      def canonical_writer?(def_node, attr_name)
+        params = def_node.parameters&.requireds
+        return false unless params&.length == 1
+
+        param_name = params.first.name
+        body_stmts = def_node.body&.body
+        return false unless body_stmts&.length == 1
+
+        stmt = body_stmts.first
+        return false unless stmt.is_a?(Prism::InstanceVariableWriteNode)
+        return false unless stmt.name.to_s == "@#{attr_name}"
+        return false unless stmt.value.is_a?(Prism::LocalVariableReadNode)
+        return false unless stmt.value.name == param_name
+
+        true
+      end
+
+      def emit_collapse(reader, writer)
+        reader_node = reader[:node]
+        writer_node = writer[:node]
+        attr_name   = reader[:name]
+
+        # Replace the attr_reader line with attr_accessor.
+        # The sym_node is the :name argument; we keep the same symbol.
+        reader_src = reader_node.location.slice
+        new_reader = reader_src.sub("attr_reader", "attr_accessor")
+
+        replace_reader = Interface::TextEdit.new(
+          range: node_to_lsp_range(reader_node),
+          new_text: new_reader
+        )
+
+        # Delete the entire writer def (all its lines).
+        writer_start_line = writer_node.location.start_line - 1
+        writer_end_line   = writer_node.location.end_line
+
+        delete_writer = Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: writer_start_line, character: 0),
+            end: Interface::Position.new(line: writer_end_line, character: 0)
+          ),
+          new_text: ""
+        )
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to attr_accessor :#{attr_name}",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: multi_edit_workspace_edit([replace_reader, delete_writer])
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_refactor/listeners/array_listener.rb

@@ -56,8 +56,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to symbol array",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
     end

data/lib/ruby_lsp/ruby_lsp_refactor/listeners/block_style_listener.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Emits block-style toggle actions on any CallNode whose block is a
+    # BlockNode (i.e. not a bare proc/lambda literal).
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Convert to do…end
+    #      receiver.method { |x| body }
+    #      →
+    #      receiver.method do |x|
+    #        body
+    #      end
+    #
+    # 2. Convert to brace block
+    #      receiver.method do |x|
+    #        body
+    #      end
+    #      →
+    #      receiver.method { |x| body }
+    #
+    # Convention: multi-statement brace blocks are always expanded to do…end.
+    # Single-statement do…end blocks are collapsed to brace style.
+    class BlockStyleListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        dispatcher.register(self, :on_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        return unless node_covers_cursor?(node)
+
+        block = node.block
+        return unless block.is_a?(Prism::BlockNode)
+
+        if brace_block?(block)
+          emit_to_do_end(node, block)
+        elsif single_statement_body?(block)
+          emit_to_brace(node, block)
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def brace_block?(block)
+        block.opening_loc.slice == "{"
+      end
+
+      def single_statement_body?(block)
+        block.body&.body&.length == 1
+      end
+
+      # ── brace → do…end ──────────────────────────────────────────────────────
+
+      def emit_to_do_end(call_node, block)
+        indent      = indent_for(call_node)
+        params_src  = params_string(block)
+        body_lines  = block.body.body.map { |s| "#{indent}  #{s.location.slice.strip}" }.join("\n")
+
+        new_block = " do#{params_src}\n#{body_lines}\n#{indent}end"
+        new_text  = call_without_block(call_node) + new_block
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to do…end block",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(call_node, new_text)
+        )
+      end
+
+      # ── do…end → brace ──────────────────────────────────────────────────────
+
+      def emit_to_brace(call_node, block)
+        params_src = params_string(block)
+        body_src   = block.body.body.first.location.slice.strip
+
+        new_block = " {#{params_src} #{body_src} }"
+        new_text  = call_without_block(call_node) + new_block
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to brace block",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(call_node, new_text)
+        )
+      end
+
+      # ── helpers ──────────────────────────────────────────────────────────────
+
+      # Returns the block parameters string including pipes, e.g. " |x, y|",
+      # or an empty string when the block takes no parameters.
+      def params_string(block)
+        return "" unless block.parameters
+
+        " #{block.parameters.location.slice}"
+      end
+
+      # Returns the source of the call node up to (but not including) the block.
+      # Works by slicing from the call's start to the block's start.
+      def call_without_block(call_node)
+        call_src   = call_node.location.slice
+        block_src  = call_node.block.location.slice
+        # Remove the block suffix (and any whitespace before it) from the call.
+        call_src[0, call_src.length - block_src.length].rstrip
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_refactor/listeners/conditional_listener.rb

@@ -127,8 +127,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to post-conditional",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 
@@ -141,8 +141,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to post-conditional",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 
@@ -155,8 +155,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to block if",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 
@@ -169,8 +169,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to block unless",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 
@@ -183,8 +183,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to unless",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 
@@ -197,8 +197,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to if",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 
@@ -212,8 +212,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Invert if/else",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  single_edit_workspace_edit(node, new_text),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 

data/lib/ruby_lsp/ruby_lsp_refactor/listeners/constant_listener.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Extract constant" when the cursor is on a literal value
+    # (Integer, Float, String, Symbol) inside a class or module body.
+    #
+    # The new constant is inserted at the top of the enclosing class/module
+    # body, and the literal is replaced with the constant name.
+    #
+    # Input (cursor on `100`):
+    #   class Processor
+    #     def run
+    #       items.first(100)
+    #     end
+    #   end
+    #
+    # Output:
+    #   class Processor
+    #     EXTRACTED_CONSTANT = 100
+    #
+    #     def run
+    #       items.first(EXTRACTED_CONSTANT)
+    #     end
+    #   end
+    class ConstantListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      LITERAL_NODE_TYPES = [
+        Prism::IntegerNode,
+        Prism::FloatNode,
+        Prism::StringNode,
+        Prism::SymbolNode
+      ].freeze
+
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        # Track the nearest enclosing class/module so we know where to insert.
+        @class_stack = []
+
+        dispatcher.register(
+          self,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+          :on_integer_node_enter,
+          :on_float_node_enter,
+          :on_string_node_enter,
+          :on_symbol_node_enter
+        )
+      end
+
+      def on_class_node_enter(node)  = @class_stack.push(node)
+      def on_class_node_leave(_node) = @class_stack.pop
+      def on_module_node_enter(node)  = @class_stack.push(node)
+      def on_module_node_leave(_node) = @class_stack.pop
+
+      def on_integer_node_enter(node) = maybe_emit(node)
+      def on_float_node_enter(node)   = maybe_emit(node)
+      def on_string_node_enter(node)  = maybe_emit(node)
+      def on_symbol_node_enter(node)  = maybe_emit(node)
+
+      private
+
+      def maybe_emit(node)
+        return unless node_covers_cursor?(node)
+        return if @class_stack.empty?
+
+        # Don't offer on constant assignments themselves.
+        enclosing = @class_stack.last
+        return unless enclosing
+
+        emit_extract_constant(node, enclosing)
+      rescue StandardError
+        nil
+      end
+
+      def emit_extract_constant(literal_node, class_node)
+        literal_src = literal_node.location.slice.strip
+        indent      = indent_for(class_node)
+        body_indent = "#{indent}  "
+
+        # Insert the constant declaration at the top of the class body.
+        # The class body starts on the line after the class declaration.
+        body_start_line = class_node.body&.location&.start_line
+        return unless body_start_line
+
+        insert_line = body_start_line - 1
+        const_decl  = "#{body_indent}EXTRACTED_CONSTANT = #{literal_src}\n\n"
+
+        insert_edit = Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: insert_line, character: 0),
+            end: Interface::Position.new(line: insert_line, character: 0)
+          ),
+          new_text: const_decl
+        )
+
+        replace_edit = Interface::TextEdit.new(
+          range: node_to_lsp_range(literal_node),
+          new_text: "EXTRACTED_CONSTANT"
+        )
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Extract constant",
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit: multi_edit_workspace_edit([insert_edit, replace_edit])
+        )
+      end
+    end
+  end
+end