ruby-lsp-refactor 0.1.0 → 0.1.2

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

@@ -12,11 +12,8 @@ module RubyLsp
     #      result = user.calculate   →  (line deleted)
     #      puts result               →  puts user.calculate
     #
-    # 2. Extract local variable
-    #      Cursor on any expression; wraps it in a new variable assignment
-    #      inserted on the line above.
-    #      user.full_name.upcase     →  name = user.full_name.upcase
-    #                                   name
+    # Note: "Extract local variable" is provided by ruby-lsp upstream as
+    # "Refactor: Extract Variable" and is intentionally not duplicated here.
     class VariableListener
       include RubyLsp::Requests::Support::Common
       include Support::NodeHelpers
@@ -40,8 +37,7 @@ module RubyLsp
           self,
           :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
 
@@ -63,15 +59,6 @@ module RubyLsp
         nil
       end
 
-      # Offer "Extract local variable" for any call expression under the cursor.
-      def on_call_node_enter(node)
-        return unless node_covers_cursor?(node)
-
-        emit_extract_local_variable(node)
-      rescue StandardError
-        nil
-      end
-
       # After the full AST walk, all read nodes are known — emit inline actions.
       def on_program_node_leave(_node)
         @pending_write_nodes.each { |w| emit_inline_variable(w) }
@@ -89,44 +76,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),
-        )
-      end
-
-      # ── extract local variable ───────────────────────────────────────────────
-
-      def emit_extract_local_variable(node)
-        expr_src   = node.location.slice.strip
-        indent     = " " * node.location.start_column
-        insert_line = node.location.start_line - 1
-
-        # Insert `variable = <expr>` on the line above, then replace the
-        # expression in-place with the variable name.
-        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: "#{indent}variable = #{expr_src}\n",
-        )
-
-        replace_edit = Interface::TextEdit.new(
-          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_INLINE,
+          edit: multi_edit_workspace_edit(edits)
         )
       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
 
@@ -95,6 +95,56 @@ module RubyLsp
         def indent_for(node)
           " " * node.location.start_column
         end
+
+        # Builds a multi-file WorkspaceEdit using document_changes, which
+        # supports both file creation (CreateFile) and text edits across
+        # multiple documents (TextDocumentEdit).
+        #
+        # +document_changes+ is an ordered array of:
+        #   Interface::CreateFile        — create a new empty file
+        #   Interface::TextDocumentEdit  — apply text edits to a file
+        #
+        # The LSP spec requires CreateFile operations to appear before any
+        # TextDocumentEdit that writes into the newly created file.
+        #
+        # @param document_changes [Array<Interface::CreateFile | Interface::TextDocumentEdit>]
+        # @return [Interface::WorkspaceEdit]
+        def multi_file_workspace_edit(document_changes)
+          Interface::WorkspaceEdit.new(document_changes: document_changes)
+        end
+
+        # Builds a TextDocumentEdit for a given URI and array of TextEdits.
+        # Used as one entry inside a multi_file_workspace_edit.
+        #
+        # @param uri   [String]  file URI, e.g. "file:///project/lib/foo.rb"
+        # @param edits [Array<Interface::TextEdit>]
+        # @return [Interface::TextDocumentEdit]
+        def text_document_edit(uri, edits)
+          Interface::TextDocumentEdit.new(
+            text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+              uri: uri,
+              version: nil
+            ),
+            edits: edits
+          )
+        end
+
+        # Builds a CreateFile operation for use in a multi_file_workspace_edit.
+        # The file is created empty; a subsequent TextDocumentEdit writes its
+        # content.
+        #
+        # @param uri [String]  file URI for the new file
+        # @return [Interface::CreateFile]
+        def create_file_operation(uri)
+          Interface::CreateFile.new(
+            kind: "create",
+            uri: uri,
+            options: Interface::CreateFileOptions.new(
+              overwrite: false,
+              ignore_if_exists: false
+            )
+          )
+        end
       end
     end
   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/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/early_return_listener_test.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class EarlyReturnListenerTest < 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
+
+      # ── core acceptance ────────────────────────────────────────────────────
+
+      def test_converts_guard_if_to_early_return
+        source = <<~RUBY
+          def charge_purchase(order)
+            if order.fulfilled?
+              OrderChargeConfirmation.new(order).create!
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 1)
+        action  = find_action(actions, "Convert to early return")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_match(/return unless order\.fulfilled\?/, edit.new_text)
+        assert_match(/OrderChargeConfirmation\.new\(order\)\.create!/, edit.new_text)
+        refute_match(/\bif\b/, edit.new_text)
+        refute_match(/\bend\b/, edit.new_text)
+      end
+
+      def test_preserves_multi_statement_body
+        source = <<~RUBY
+          def process(order)
+            if order.valid?
+              order.charge!
+              order.notify!
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 1)
+        action  = find_action(actions, "Convert to early return")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_match(/return unless order\.valid\?/, edit.new_text)
+        assert_match(/order\.charge!/, edit.new_text)
+        assert_match(/order\.notify!/, edit.new_text)
+      end
+
+      def test_preserves_indentation
+        source = <<~RUBY
+          class Service
+            def call(user)
+              if user.active?
+                user.run!
+              end
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 2)
+        action  = find_action(actions, "Convert to early return")
+        refute_nil action
+
+        edit = single_edit(action)
+        # The edit replaces the if node range (start_column=4), so new_text
+        # begins with the node's own indentation (4 spaces).
+        assert_match(/\A    return unless user\.active\?/, edit.new_text)
+        assert_match(/user\.run!/, edit.new_text)
+      end
+
+      # ── negative cases ─────────────────────────────────────────────────────
+
+      def test_does_not_offer_when_if_has_else
+        source = <<~RUBY
+          def process(order)
+            if order.valid?
+              order.charge!
+            else
+              order.reject!
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 1)
+        assert_nil find_action(actions, "Convert to early return")
+      end
+
+      def test_does_not_offer_when_if_has_elsif
+        source = <<~RUBY
+          def process(order)
+            if order.paid?
+              order.complete!
+            elsif order.pending?
+              order.charge!
+            end
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 1)
+        assert_nil find_action(actions, "Convert to early return")
+      end
+
+      def test_does_not_offer_when_if_is_not_first_statement
+        source = <<~RUBY
+          def process(order)
+            order.validate!
+            if order.valid?
+              order.charge!
+            end
+          end
+        RUBY
+
+        # Cursor on the if (line 2) — it is not the first statement
+        actions = code_actions_for(source, line: 2)
+        assert_nil find_action(actions, "Convert to early return")
+      end
+
+      def test_does_not_offer_outside_a_method
+        source = <<~RUBY
+          if user.active?
+            user.run!
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to early return")
+      end
+
+      def test_does_not_offer_for_post_conditional
+        source = "user.run! if user.active?\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to early return")
+      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/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