ruby-lsp-refactor 0.1.0 → 0.1.2

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

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

data/lib/ruby_lsp/ruby_lsp_refactor/addon.rb

@@ -1,14 +1,42 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/addon"
-require "ruby_lsp/requests/code_actions"
-require "ruby_lsp/requests/code_action_resolve"
+
+# Conditionals
 require_relative "listeners/conditional_listener"
-require_relative "listeners/variable_listener"
+require_relative "listeners/early_return_listener"
+
+# Strings
 require_relative "listeners/string_listener"
-require_relative "listeners/hash_listener"
+require_relative "listeners/string_array_listener"
+require_relative "listeners/string_freeze_listener"
+
+# Collections
 require_relative "listeners/array_listener"
+require_relative "listeners/hash_listener"
+require_relative "listeners/enumerable_listener"
+
+# Variables & constants
+require_relative "listeners/variable_listener"
+require_relative "listeners/constant_listener"
+
+# Methods & classes
 require_relative "listeners/method_listener"
+require_relative "listeners/extract_predicate_listener"
+require_relative "listeners/accessor_listener"
+require_relative "listeners/rescue_listener"
+require_relative "listeners/super_listener"
+
+# Multi-file
+require_relative "listeners/extract_include_file_listener"
+
+# Operators & blocks
+require_relative "listeners/tap_listener"
+require_relative "listeners/logical_operator_listener"
+require_relative "listeners/raise_listener"
+
+# RSpec
+require_relative "listeners/rspec_let_listener"
 
 module RubyLsp
   module Refactor
@@ -31,7 +59,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,30 +90,39 @@ 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)
         response_builder = RubyLsp::ResponseBuilders::CollectionResponseBuilder.new
         dispatcher       = Prism::Dispatcher.new
 
-        # Phase 1 – Local rewrites
         ConditionalListener.new(response_builder, node_context, dispatcher)
+        EarlyReturnListener.new(response_builder, node_context, dispatcher)
         StringListener.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)
+        StringArrayListener.new(response_builder, node_context, dispatcher)
+        StringFreezeListener.new(response_builder, node_context, dispatcher)
         ArrayListener.new(response_builder, node_context, dispatcher)
-
-        # Phase 3 – Advanced structure
+        HashListener.new(response_builder, node_context, dispatcher)
+        EnumerableListener.new(response_builder, node_context, dispatcher)
+        VariableListener.new(response_builder, node_context, dispatcher)
+        ConstantListener.new(response_builder, node_context, dispatcher)
         MethodListener.new(response_builder, node_context, dispatcher)
+        ExtractPredicateListener.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)
+        ExtractIncludeFileListener.new(response_builder, node_context, dispatcher)
+        TapListener.new(response_builder, node_context, dispatcher)
+        LogicalOperatorListener.new(response_builder, node_context, dispatcher)
+        RaiseListener.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/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

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Convert to early return" when the cursor is on a guard `if` block
+    # that is the first statement in a method body and has no `else` branch.
+    #
+    # From "Prefer early returns" in Refactoring Rails: replace a top-level
+    # guard `if` with `return unless` so the happy path is not nested.
+    #
+    # Input (cursor on the `if` line):
+    #   def charge_purchase(order)
+    #     if order.fulfilled?
+    #       OrderChargeConfirmation.new(order).create!
+    #     end
+    #   end
+    #
+    # Output:
+    #   def charge_purchase(order)
+    #     return unless order.fulfilled?
+    #     OrderChargeConfirmation.new(order).create!
+    #   end
+    #
+    # Eligibility:
+    #   - Block-form `if` (has end_keyword_loc) with no else/elsif.
+    #   - Must be the first statement in the enclosing method body.
+    #   - Body may contain one or more statements.
+    class EarlyReturnListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+        @current_def      = nil
+
+        dispatcher.register(
+          self,
+          :on_def_node_enter,
+          :on_def_node_leave,
+          :on_if_node_enter
+        )
+      end
+
+      def on_def_node_enter(node)
+        @current_def = node
+      rescue StandardError
+        nil
+      end
+
+      def on_def_node_leave(_node)
+        @current_def = nil
+      rescue StandardError
+        nil
+      end
+
+      def on_if_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless eligible?(node)
+
+        emit_early_return(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def eligible?(node)
+        return false unless node.end_keyword_loc # block-form only
+        return false if node.subsequent # no else/elsif
+        return false unless node.statements&.body&.any?
+        return false unless first_statement_in_def?(node)
+
+        true
+      end
+
+      def first_statement_in_def?(if_node)
+        return false unless @current_def
+
+        body = @current_def.body
+        return false unless body.is_a?(Prism::StatementsNode)
+
+        body.body.first.equal?(if_node)
+      end
+
+      def emit_early_return(node)
+        indent     = indent_for(node)
+        cond_src   = node.predicate.location.slice.strip
+        body_lines = node.statements.body
+                         .map { |s| "#{indent}#{s.location.slice.strip}" }
+                         .join("\n")
+
+        new_text = "#{indent}return unless #{cond_src}\n#{body_lines}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to early return",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Detects common Enumerable method-chain patterns and offers a single
+    # collapsed replacement.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. map + flatten(1) / flatten  →  flat_map
+    #      items.map { |i| i.tags }.flatten(1)  →  items.flat_map { |i| i.tags }
+    #
+    # 2. select + first  →  find
+    #      users.select { |u| u.admin? }.first  →  users.find { |u| u.admin? }
+    #
+    # 3. map + compact  →  filter_map
+    #      items.map { |i| i.value }.compact  →  items.filter_map { |i| i.value }
+    #
+    # All three patterns share the same structure:
+    #   outer_call( receiver: inner_call( block: BlockNode ) )
+    # where outer_call has no block of its own.
+    class EnumerableListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      # { outer_method => { inner_method => replacement } }
+      PATTERNS = {
+        flatten: { map: "flat_map" },
+        first: { select: "find" },
+        compact: { map: "filter_map" }
+      }.freeze
+
+      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)
+        return if node.block # outer call must not have its own block
+
+        outer_name = node.name
+        return unless PATTERNS.key?(outer_name)
+
+        # flatten is only eligible when called with no args or with arg `1`.
+        return if outer_name == :flatten && !flatten_eligible?(node)
+
+        inner = node.receiver
+        return unless inner.is_a?(Prism::CallNode) && inner.block.is_a?(Prism::BlockNode)
+
+        replacement = PATTERNS[outer_name][inner.name]
+        return unless replacement
+
+        emit_collapse(node, inner, replacement)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # flatten() and flatten(1) are eligible; flatten(2+) changes semantics.
+      def flatten_eligible?(node)
+        args = node.arguments&.arguments
+        return true if args.nil? || args.empty?
+        return true if args.length == 1 && args.first.is_a?(Prism::IntegerNode) &&
+                       args.first.location.slice == "1"
+
+        false
+      end
+
+      def emit_collapse(outer_node, inner_node, replacement)
+        # Reconstruct: <receiver>.<replacement> <block>
+        receiver_src = inner_node.receiver.location.slice.strip
+        block_src    = inner_node.block.location.slice.strip
+
+        new_text = "#{indent_for(outer_node)}#{receiver_src}.#{replacement} #{block_src}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to .#{replacement}",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(outer_node, new_text)
+        )
+      end
+    end
+  end
+end