ruby-lsp-refactor 0.1.0 → 0.1.1

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Wrap in freeze" on any unfrozen string literal, and
+    # "Remove freeze" on a string that already calls .freeze.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Wrap in freeze
+    #      "hello"          →   "hello".freeze
+    #
+    # 2. Remove freeze
+    #      "hello".freeze   →   "hello"
+    class StringFreezeListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        # Track start offsets of string nodes that are already receivers of
+        # .freeze so on_string_node_enter can skip them.  Populated during
+        # on_call_node_enter which fires for the outer CallNode first.
+        @frozen_string_offsets = {}
+
+        dispatcher.register(self, :on_call_node_enter, :on_string_node_enter)
+      end
+
+      # Fires for every CallNode — including `.freeze` calls.
+      # We register this before on_string_node_enter so the offset set is
+      # populated before the inner StringNode callback fires.
+      def on_call_node_enter(node)
+        return unless node.name == :freeze
+        return unless node.receiver.is_a?(Prism::StringNode)
+        return unless node.arguments.nil?
+
+        # Mark the receiver string so on_string_node_enter skips it.
+        @frozen_string_offsets[node.receiver.location.start_offset] = true
+
+        return unless node_covers_cursor?(node)
+
+        emit_remove_freeze(node)
+      rescue StandardError
+        nil
+      end
+
+      # Offer "Wrap in freeze" for plain string literals that are not already
+      # the receiver of a .freeze call.
+      def on_string_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return if @frozen_string_offsets.key?(node.location.start_offset)
+
+        emit_wrap_freeze(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def emit_wrap_freeze(node)
+        str_src  = node.location.slice
+        new_text = "#{str_src}.freeze"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Wrap in freeze",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
+        )
+      end
+
+      def emit_remove_freeze(node)
+        str_src = node.receiver.location.slice
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Remove freeze",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, str_src)
+        )
+      end
+    end
+  end
+end

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

@@ -52,8 +52,8 @@ module RubyLsp
 
         @response_builder << Interface::CodeAction.new(
           title: "Convert to interpolated string",
-          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/super_listener.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Converts a bare `super` (ForwardingSuperNode) inside a def that has
+    # parameters into an explicit `super(param1, param2, ...)`.
+    #
+    # Input (cursor on `super`):
+    #   def initialize(name, age)
+    #     super
+    #   end
+    #
+    # Output:
+    #   def initialize(name, age)
+    #     super(name, age)
+    #   end
+    #
+    # Bare `super` forwards all arguments implicitly; making them explicit
+    # is safer when the method signature changes over time.
+    class SuperListener
+      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_forwarding_super_node_enter
+        )
+      end
+
+      def on_def_node_enter(node)
+        @current_def = node
+      end
+
+      def on_def_node_leave(_node)
+        @current_def = nil
+      end
+
+      def on_forwarding_super_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless @current_def
+        return unless has_params?(@current_def)
+
+        emit_explicit_super(node, @current_def)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def has_params?(def_node)
+        params = def_node.parameters
+        return false unless params
+
+        params.requireds.any? || params.optionals.any? || params.keywords.any?
+      end
+
+      def emit_explicit_super(super_node, def_node)
+        param_names = collect_param_names(def_node.parameters)
+        new_text    = "#{indent_for(super_node)}super(#{param_names.join(", ")})"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to explicit super(#{param_names.join(", ")})",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(super_node, new_text)
+        )
+      end
+
+      def collect_param_names(params_node)
+        names = []
+        params_node.requireds.each do |p|
+          names << p.name.to_s if p.respond_to?(:name)
+        end
+        params_node.optionals.each do |p|
+          names << p.name.to_s if p.respond_to?(:name)
+        end
+        params_node.keywords.each do |p|
+          # keyword params: `name:` — pass as `name: name`
+          kw_name = p.name.to_s.delete_suffix(":")
+          names << "#{kw_name}: #{kw_name}"
+        end
+        names
+      end
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ module RubyLsp
           :on_local_variable_write_node_enter,
           :on_local_variable_read_node_enter,
           :on_call_node_enter,
-          :on_program_node_leave,
+          :on_program_node_leave
         )
       end
 
@@ -89,15 +89,15 @@ module RubyLsp
 
         @read_nodes[write_node.name].each do |read_node|
           edits << Interface::TextEdit.new(
-            range:    node_to_lsp_range(read_node),
-            new_text: rhs_text,
+            range: node_to_lsp_range(read_node),
+            new_text: rhs_text
           )
         end
 
         @response_builder << Interface::CodeAction.new(
           title: "Inline variable '#{write_node.name}'",
-          kind:  Constant::CodeActionKind::REFACTOR_INLINE,
-          edit:  multi_edit_workspace_edit(edits),
+          kind: Constant::CodeActionKind::REFACTOR_INLINE,
+          edit: multi_edit_workspace_edit(edits)
         )
       end
 
@@ -113,20 +113,20 @@ module RubyLsp
         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),
+            end: Interface::Position.new(line: insert_line, character: 0)
           ),
-          new_text: "#{indent}variable = #{expr_src}\n",
+          new_text: "#{indent}variable = #{expr_src}\n"
         )
 
         replace_edit = Interface::TextEdit.new(
-          range:    node_to_lsp_range(node),
-          new_text: "variable",
+          range: node_to_lsp_range(node),
+          new_text: "variable"
         )
 
         @response_builder << Interface::CodeAction.new(
           title: "Extract local variable",
-          kind:  Constant::CodeActionKind::REFACTOR_EXTRACT,
-          edit:  multi_edit_workspace_edit([insert_edit, replace_edit]),
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit: multi_edit_workspace_edit([insert_edit, replace_edit])
         )
       end
     end

data/lib/ruby_lsp/ruby_lsp_refactor/support/node_helpers.rb

@@ -18,13 +18,13 @@ module RubyLsp
           loc = node.location
           Interface::Range.new(
             start: Interface::Position.new(
-              line:      loc.start_line - 1,
-              character: loc.start_column,
+              line: loc.start_line - 1,
+              character: loc.start_column
             ),
             end: Interface::Position.new(
-              line:      loc.end_line - 1,
-              character: loc.end_column,
-            ),
+              line: loc.end_line - 1,
+              character: loc.end_column
+            )
           )
         end
 
@@ -56,9 +56,9 @@ module RubyLsp
           Interface::WorkspaceEdit.new(
             changes: {
               @node_context.uri => [
-                Interface::TextEdit.new(range: node_to_lsp_range(node), new_text: new_text),
-              ],
-            },
+                Interface::TextEdit.new(range: node_to_lsp_range(node), new_text: new_text)
+              ]
+            }
           )
         end
 
@@ -68,7 +68,7 @@ module RubyLsp
         # @return [Interface::WorkspaceEdit]
         def multi_edit_workspace_edit(edits)
           Interface::WorkspaceEdit.new(
-            changes: { @node_context.uri => edits },
+            changes: { @node_context.uri => edits }
           )
         end
 
@@ -81,10 +81,10 @@ module RubyLsp
           line = node.location.start_line - 1
           Interface::TextEdit.new(
             range: Interface::Range.new(
-              start: Interface::Position.new(line: line,     character: 0),
-              end:   Interface::Position.new(line: line + 1, character: 0),
+              start: Interface::Position.new(line: line, character: 0),
+              end: Interface::Position.new(line: line + 1, character: 0)
             ),
-            new_text: "",
+            new_text: ""
           )
         end
 

data/lib/ruby_lsp/test_helper.rb

@@ -31,16 +31,16 @@ module RubyLsp
         uri          = URI::Generic.from_path(path: "/test/fixture.rb")
         global_state = RubyLsp::GlobalState.new
         document     = RubyLsp::RubyDocument.new(
-          source:       source,
-          version:      1,
-          uri:          uri,
-          global_state: global_state,
+          source: source,
+          version: 1,
+          uri: uri,
+          global_state: global_state
         )
 
         # LSP range hash — same shape the real server passes to CodeActions.
         range = {
           start: { line: line, character: char },
-          end:   { line: line, character: char },
+          end: { line: line, character: char }
         }
 
         RubyLsp::Refactor::Addon.refactor_actions_for(document, range)

data/test/ruby_lsp_refactor/accessor_listener_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class AccessorListenerTest < Minitest::Test
+      include RubyLsp::Refactor::TestHelper
+
+      def find_action(actions, title_pattern)
+        actions.find { |a| a.title.match?(title_pattern) }
+      end
+
+      def test_collapses_attr_reader_and_writer_into_attr_accessor
+        source = <<~RUBY
+          class User
+            attr_reader :name
+
+            def name=(val)
+              @name = val
+            end
+          end
+        RUBY
+
+        # Cursor on the attr_reader line
+        actions = code_actions_for(source, line: 1)
+        action  = find_action(actions, /attr_accessor :name/)
+        refute_nil action
+
+        edits = action.edit.changes.values.flatten
+        assert_equal 2, edits.size
+
+        replace_edit = edits.find { |e| e.new_text.include?("attr_accessor") }
+        delete_edit  = edits.find { |e| e.new_text == "" }
+
+        refute_nil replace_edit
+        refute_nil delete_edit
+        assert_match(/attr_accessor :name/, replace_edit.new_text)
+      end
+
+      def test_offers_action_from_writer_def_line_too
+        source = <<~RUBY
+          class User
+            attr_reader :name
+
+            def name=(val)
+              @name = val
+            end
+          end
+        RUBY
+
+        # Cursor on the def name= line
+        actions = code_actions_for(source, line: 3)
+        action  = find_action(actions, /attr_accessor :name/)
+        refute_nil action
+      end
+
+      def test_does_not_offer_when_no_matching_writer
+        source = <<~RUBY
+          class User
+            attr_reader :name
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 1)
+        assert_nil find_action(actions, /attr_accessor/)
+      end
+
+      def test_does_not_offer_for_non_canonical_writer
+        # Writer has extra logic — not a simple passthrough
+        source = <<~RUBY
+          class User
+            attr_reader :name
+
+            def name=(val)
+              @name = val.strip
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 1)
+        assert_nil find_action(actions, /attr_accessor/)
+      end
+
+      def test_does_not_raise_on_empty_source
+        assert_silent { code_actions_for("", line: 0) }
+      end
+    end
+  end
+end

data/test/ruby_lsp_refactor/block_style_listener_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class BlockStyleListenerTest < Minitest::Test
+      include RubyLsp::Refactor::TestHelper
+
+      def find_action(actions, title)
+        actions.find { |a| a.title == title }
+      end
+
+      def single_edit(action)
+        edits = action.edit.changes.values.flatten
+        assert_equal 1, edits.size
+        edits.first
+      end
+
+      # ── brace → do…end ────────────────────────────────────────────────────
+
+      def test_converts_brace_block_to_do_end
+        source = "users.each { |u| u.activate! }\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to do…end block")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_match(/do \|u\|/, edit.new_text)
+        assert_match(/u\.activate!/, edit.new_text)
+        assert_match(/end/, edit.new_text)
+      end
+
+      def test_brace_to_do_end_preserves_indentation
+        source = "  users.each { |u| u.activate! }\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to do…end block")
+        refute_nil action
+
+        edit = single_edit(action)
+        # The edit replaces the node range which starts at column 2, so
+        # new_text begins at the call itself (no leading spaces).
+        assert_match(/\Ausers\.each do \|u\|/, edit.new_text)
+        # Body is indented 2 (node column) + 2 (block body) = 4 spaces.
+        assert_match(/^    u\.activate!/, edit.new_text)
+        # Closing end is at the node's own indentation level (2 spaces).
+        assert_match(/^  end$/, edit.new_text)
+      end
+
+      def test_brace_to_do_end_without_params
+        source = "3.times { puts 'hi' }\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to do…end block")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_match(/do\n/, edit.new_text)
+        refute_match(/\|/, edit.new_text)
+      end
+
+      # ── do…end → brace ────────────────────────────────────────────────────
+
+      def test_converts_do_end_block_to_brace
+        source = <<~RUBY
+          users.each do |u|
+            u.activate!
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to brace block")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_match(/\{ \|u\| u\.activate! \}/, edit.new_text)
+      end
+
+      def test_does_not_offer_brace_for_multi_statement_do_end
+        source = <<~RUBY
+          users.each do |u|
+            u.activate!
+            u.notify!
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to brace block")
+      end
+
+      # ── resilience ─────────────────────────────────────────────────────────
+
+      def test_does_not_raise_on_empty_source
+        assert_silent { code_actions_for("", line: 0) }
+      end
+    end
+  end
+end

data/test/ruby_lsp_refactor/constant_listener_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class ConstantListenerTest < Minitest::Test
+      include RubyLsp::Refactor::TestHelper
+
+      def find_action(actions, title)
+        actions.find { |a| a.title == title }
+      end
+
+      def test_extracts_integer_literal_to_constant
+        source = <<~RUBY
+          class Processor
+            def run
+              items.first(100)
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 2)
+        action  = find_action(actions, "Extract constant")
+        refute_nil action
+
+        edits = action.edit.changes.values.flatten
+        assert_equal 2, edits.size
+
+        insert_edit  = edits.find { |e| e.new_text.include?("EXTRACTED_CONSTANT") && e.new_text.include?("=") }
+        replace_edit = edits.find { |e| e.new_text == "EXTRACTED_CONSTANT" }
+
+        refute_nil insert_edit
+        refute_nil replace_edit
+        assert_match(/EXTRACTED_CONSTANT = 100/, insert_edit.new_text)
+      end
+
+      def test_extracts_string_literal_to_constant
+        source = <<~RUBY
+          class Mailer
+            def subject
+              "Welcome to the app"
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 2)
+        action  = find_action(actions, "Extract constant")
+        refute_nil action
+
+        edits = action.edit.changes.values.flatten
+        insert_edit = edits.find { |e| e.new_text.include?("EXTRACTED_CONSTANT") && e.new_text.include?("=") }
+        assert_match(/EXTRACTED_CONSTANT = "Welcome to the app"/, insert_edit.new_text)
+      end
+
+      def test_does_not_offer_outside_class
+        source = "items.first(100)\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Extract constant")
+      end
+
+      def test_does_not_raise_on_empty_source
+        assert_silent { code_actions_for("", line: 0) }
+      end
+    end
+  end
+end

data/test/ruby_lsp_refactor/enumerable_listener_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class EnumerableListenerTest < Minitest::Test
+      include RubyLsp::Refactor::TestHelper
+
+      def find_action(actions, title)
+        actions.find { |a| a.title == title }
+      end
+
+      def single_edit(action)
+        edits = action.edit.changes.values.flatten
+        assert_equal 1, edits.size
+        edits.first
+      end
+
+      # ── map + flatten → flat_map ───────────────────────────────────────────
+
+      def test_converts_map_flatten_1_to_flat_map
+        source = "items.map { |i| i.tags }.flatten(1)\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to .flat_map")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_equal "items.flat_map { |i| i.tags }", edit.new_text.strip
+      end
+
+      def test_converts_map_flatten_no_arg_to_flat_map
+        source = "items.map { |i| i.tags }.flatten\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to .flat_map")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_equal "items.flat_map { |i| i.tags }", edit.new_text.strip
+      end
+
+      def test_does_not_offer_flat_map_for_flatten_2
+        source = "items.map { |i| i.tags }.flatten(2)\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to .flat_map")
+      end
+
+      # ── select + first → find ─────────────────────────────────────────────
+
+      def test_converts_select_first_to_find
+        source = "users.select { |u| u.admin? }.first\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to .find")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_equal "users.find { |u| u.admin? }", edit.new_text.strip
+      end
+
+      # ── map + compact → filter_map ────────────────────────────────────────
+
+      def test_converts_map_compact_to_filter_map
+        source = "items.map { |i| i.value }.compact\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to .filter_map")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_equal "items.filter_map { |i| i.value }", edit.new_text.strip
+      end
+
+      # ── resilience ─────────────────────────────────────────────────────────
+
+      def test_does_not_raise_on_empty_source
+        assert_silent { code_actions_for("", line: 0) }
+      end
+    end
+  end
+end