ruby-lsp-refactor 0.1.1 → 0.1.2

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Convert to tap" when the cursor is inside a method whose body
+    # is a sequence of calls on the same receiver followed by a bare return
+    # of that receiver.
+    #
+    # From "Encourage use of Object#tap" in Refactoring Rails: groups
+    # operations on the same object into a tap block and removes the explicit
+    # return at the end.
+    #
+    # Input (cursor anywhere inside the method):
+    #   def do_something
+    #     obj.do_first_thing
+    #     obj.do_second_thing
+    #     obj.do_third_thing
+    #     obj
+    #   end
+    #
+    # Output:
+    #   def do_something
+    #     obj.tap do |o|
+    #       o.do_first_thing
+    #       o.do_second_thing
+    #       o.do_third_thing
+    #     end
+    #   end
+    #
+    # Eligibility:
+    #   - Method body has at least two statements.
+    #   - All statements except the last are CallNodes whose receiver is a
+    #     variable_call (bare local variable or method with no receiver).
+    #   - All those receivers share the same name.
+    #   - The last statement is a bare variable_call with the same name.
+    class TapListener
+      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_def_node_enter)
+      end
+
+      def on_def_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless (receiver_name = tap_eligible?(node))
+
+        emit_convert_to_tap(node, receiver_name)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Returns the shared receiver name if the method body is tap-eligible,
+      # or nil otherwise.
+      def tap_eligible?(def_node)
+        body = def_node.body
+        return unless body.is_a?(Prism::StatementsNode)
+
+        stmts = body.body
+        return unless stmts.length >= 2
+
+        last = stmts.last
+        calls = stmts[0..-2]
+
+        # Last statement must be a bare variable_call.
+        return unless last.is_a?(Prism::CallNode) && last.variable_call?
+
+        receiver_name = last.name
+
+        # Every preceding statement must be a non-variable call whose receiver
+        # is a variable_call with the same name.
+        all_match = calls.all? do |c|
+          c.is_a?(Prism::CallNode) &&
+            !c.variable_call? &&
+            c.receiver.is_a?(Prism::CallNode) &&
+            c.receiver.variable_call? &&
+            c.receiver.name == receiver_name
+        end
+
+        receiver_name if all_match
+      end
+
+      def emit_convert_to_tap(def_node, receiver_name)
+        body_indent = "#{indent_for(def_node)}  "
+        tap_indent  = "#{body_indent}  "
+
+        stmts = def_node.body.body
+        calls = stmts[0..-2]
+
+        # Rebuild each call as `o.method(args)` using the slice after the receiver.
+        tap_lines = calls.map do |c|
+          full      = c.location.slice.strip
+          recv_src  = c.receiver.location.slice.strip
+          # Everything after "recv." is the method call part.
+          method_part = full[(recv_src.length + 1)..]
+          "#{tap_indent}o.#{method_part}"
+        end.join("\n")
+
+        new_body = "#{body_indent}#{receiver_name}.tap do |o|\n" \
+                   "#{tap_lines}\n" \
+                   "#{body_indent}end"
+
+        # Replace the entire method body (all statements) with the tap block.
+        body_node  = def_node.body
+        body_range = Interface::Range.new(
+          start: Interface::Position.new(
+            line: body_node.location.start_line - 1,
+            character: body_node.location.start_column
+          ),
+          end: Interface::Position.new(
+            line: body_node.location.end_line - 1,
+            character: body_node.location.end_column
+          )
+        )
+
+        edit = Interface::TextEdit.new(range: body_range, new_text: new_body)
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to tap",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: multi_edit_workspace_edit([edit])
+        )
+      end
+    end
+  end
+end

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,7 +37,6 @@ module RubyLsp
           self,
           :on_local_variable_write_node_enter,
           :on_local_variable_read_node_enter,
-          :on_call_node_enter,
           :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) }
@@ -100,35 +87,6 @@ module RubyLsp
           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])
-        )
-      end
     end
   end
 end

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

@@ -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/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/extract_include_file_listener_test.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class ExtractIncludeFileListenerTest < Minitest::Test
+      include RubyLsp::Refactor::TestHelper
+
+      def find_action(actions, title_pattern)
+        actions.find { |a| a.title.match?(title_pattern) }
+      end
+
+      # ── core acceptance ────────────────────────────────────────────────────
+
+      def test_extracts_module_to_new_file
+        source = <<~RUBY
+          module Greetable
+            def greet = "hello"
+          end
+
+          class User
+            include Greetable
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        assert_match(/greetable\.rb/, action.title)
+
+        doc_changes = action.edit.document_changes
+        assert_equal 3, doc_changes.length,
+                     "Expected CreateFile + 2 TextDocumentEdits, got #{doc_changes.length}"
+      end
+
+      def test_create_file_operation_is_first
+        source = <<~RUBY
+          module Greetable
+            def greet = "hello"
+          end
+
+          class User; end
+        RUBY
+
+        actions    = code_actions_for(source, line: 0)
+        action     = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        create_op = action.edit.document_changes.first
+        assert_equal "create", create_op.kind
+        assert_match(/greetable\.rb/, create_op.uri)
+      end
+
+      def test_new_file_content_includes_frozen_comment_and_source
+        source = <<~RUBY
+          module Greetable
+            def greet = "hello"
+          end
+
+          class User; end
+        RUBY
+
+        actions    = code_actions_for(source, line: 0)
+        action     = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        # Second document_change is the TextDocumentEdit writing the new file.
+        write_edit = action.edit.document_changes[1]
+        content    = write_edit.edits.first.new_text
+
+        assert_match(/# frozen_string_literal: true/, content)
+        assert_match(/module Greetable/, content)
+        assert_match(/def greet = "hello"/, content)
+      end
+
+      def test_source_file_is_replaced_with_require_relative
+        source = <<~RUBY
+          module Greetable
+            def greet = "hello"
+          end
+
+          class User; end
+        RUBY
+
+        actions    = code_actions_for(source, line: 0)
+        action     = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        # Third document_change edits the source file.
+        source_edit = action.edit.document_changes[2]
+        new_text    = source_edit.edits.first.new_text
+
+        assert_match(/require_relative "greetable"/, new_text)
+        refute_match(/module Greetable/, new_text)
+      end
+
+      def test_new_file_uri_is_in_same_directory_as_source
+        source = <<~RUBY
+          module Greetable
+            def greet = "hello"
+          end
+
+          class User; end
+        RUBY
+
+        actions    = code_actions_for(source, line: 0)
+        action     = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        create_op      = action.edit.document_changes.first
+        source_dir     = File.dirname(URI("file:///test/fixture.rb").path)
+        expected_path  = File.join(source_dir, "greetable.rb")
+
+        assert_equal "file://#{expected_path}", create_op.uri
+      end
+
+      def test_converts_camel_case_module_name_to_snake_case_filename
+        source = <<~RUBY
+          module MyHelperModule
+            def help = true
+          end
+
+          class App; end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        assert_match(/my_helper_module\.rb/, action.title)
+        create_op = action.edit.document_changes.first
+        assert_match(/my_helper_module\.rb/, create_op.uri)
+      end
+
+      def test_works_for_class_nodes_too
+        source = <<~RUBY
+          class AdminUser
+            def admin? = true
+          end
+
+          class User; end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, /Extract to include file/)
+        refute_nil action
+
+        assert_match(/admin_user\.rb/, action.title)
+      end
+
+      # ── negative cases ─────────────────────────────────────────────────────
+
+      def test_does_not_offer_when_module_is_only_top_level_node
+        # Nothing else in the file — extraction would leave an empty source.
+        source = <<~RUBY
+          module Greetable
+            def greet = "hello"
+          end
+        RUBY
+
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, /Extract to include file/)
+      end
+
+      def test_does_not_offer_for_nested_module
+        source = <<~RUBY
+          class User
+            module Callbacks
+              def before_save = nil
+            end
+          end
+        RUBY
+
+        # Cursor on the nested module (line 1)
+        actions = code_actions_for(source, line: 1)
+        assert_nil find_action(actions, /Extract to include file/)
+      end
+
+      # ── resilience ─────────────────────────────────────────────────────────
+
+      def test_does_not_raise_on_empty_source
+        assert_silent { code_actions_for("", line: 0) }
+      end
+    end
+  end
+end