ruby-lsp-refactor 0.1.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Emits a "Convert to interpolated string" code action when the cursor is
+    # on a single-quoted StringNode.
+    #
+    # Input:   'hello world'
+    # Output:  "hello world"
+    #
+    # The action only upgrades the delimiters; the developer can then type #{}
+    # to add interpolation.  Backslash-escape sequences that are meaningful in
+    # double-quoted strings but literal in single-quoted strings (e.g. \n, \t)
+    # are left as-is — the developer is expected to review them.
+    class StringListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      # @param response_builder [RubyLsp::ResponseBuilders::CollectionResponseBuilder]
+      # @param node_context     [RubyLsp::NodeContext]
+      # @param dispatcher       [Prism::Dispatcher]
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        dispatcher.register(self, :on_string_node_enter)
+      end
+
+      def on_string_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless single_quoted?(node)
+
+        emit_convert_to_interpolated(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Returns true when the string literal uses single-quote delimiters.
+      def single_quoted?(node)
+        node.opening_loc&.slice == "'"
+      end
+
+      def emit_convert_to_interpolated(node)
+        # Escape any bare double-quotes inside the string content so the
+        # resulting double-quoted literal remains valid.
+        content  = node.unescaped.gsub('"', '\\"')
+        new_text = "\"#{content}\""
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to interpolated string",
+          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/variable_listener.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Handles variable-related code actions.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Inline variable
+    #      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
+    class VariableListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      # @param response_builder [RubyLsp::ResponseBuilders::CollectionResponseBuilder]
+      # @param node_context     [RubyLsp::NodeContext]
+      # @param dispatcher       [Prism::Dispatcher]
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        # Collect all read nodes keyed by variable name so we can cross-reference
+        # them when we encounter a matching write node.
+        @read_nodes = Hash.new { |h, k| h[k] = [] } # { name => [ReadNode, ...] }
+
+        # Defer inline-variable actions until after the full walk so that all
+        # read nodes are collected before we build the edits.
+        @pending_write_nodes = []
+
+        dispatcher.register(
+          self,
+          :on_local_variable_write_node_enter,
+          :on_local_variable_read_node_enter,
+          :on_call_node_enter,
+          :on_program_node_leave,
+        )
+      end
+
+      # ── dispatcher callbacks ────────────────────────────────────────────────
+
+      def on_local_variable_read_node_enter(node)
+        @read_nodes[node.name] << node
+      rescue StandardError
+        nil
+      end
+
+      def on_local_variable_write_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless node.value
+
+        # Defer: we need all reads collected before building the edit.
+        @pending_write_nodes << node
+      rescue StandardError
+        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) }
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # ── inline variable ─────────────────────────────────────────────────────
+
+      def emit_inline_variable(write_node)
+        rhs_text = write_node.value.location.slice.strip
+        edits    = [delete_line_edit(write_node)]
+
+        @read_nodes[write_node.name].each do |read_node|
+          edits << Interface::TextEdit.new(
+            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]),
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Refactor
+    module Support
+      # Shared helpers mixed into every listener.
+      #
+      # Provides:
+      #   - node_to_lsp_range(node)       – Prism location → Interface::Range
+      #   - node_covers_cursor?(node)      – overlap check against @node_context.range
+      #   - single_edit_workspace_edit(…)  – convenience WorkspaceEdit factory
+      module NodeHelpers
+        # Converts a Prism node's location to an LSP Interface::Range.
+        #
+        # @param node [Prism::Node]
+        # @return [Interface::Range]
+        def node_to_lsp_range(node)
+          loc = node.location
+          Interface::Range.new(
+            start: Interface::Position.new(
+              line:      loc.start_line - 1,
+              character: loc.start_column,
+            ),
+            end: Interface::Position.new(
+              line:      loc.end_line - 1,
+              character: loc.end_column,
+            ),
+          )
+        end
+
+        # Returns true when the node's source range overlaps the cursor/selection
+        # range provided by the LSP client via @node_context.
+        #
+        # @param node [Prism::Node]
+        # @return [Boolean]
+        def node_covers_cursor?(node)
+          cursor = @node_context.range
+          return true unless cursor
+
+          node_start = node.location.start_line - 1
+          node_end   = node.location.end_line   - 1
+
+          cursor_start = cursor.start.line
+          cursor_end   = cursor.end.line
+
+          node_start <= cursor_end && node_end >= cursor_start
+        end
+
+        # Builds a WorkspaceEdit containing a single TextEdit that replaces the
+        # entire range of +node+ with +new_text+.
+        #
+        # @param node     [Prism::Node]
+        # @param new_text [String]
+        # @return [Interface::WorkspaceEdit]
+        def single_edit_workspace_edit(node, new_text)
+          Interface::WorkspaceEdit.new(
+            changes: {
+              @node_context.uri => [
+                Interface::TextEdit.new(range: node_to_lsp_range(node), new_text: new_text),
+              ],
+            },
+          )
+        end
+
+        # Builds a WorkspaceEdit from an arbitrary array of TextEdit objects.
+        #
+        # @param edits [Array<Interface::TextEdit>]
+        # @return [Interface::WorkspaceEdit]
+        def multi_edit_workspace_edit(edits)
+          Interface::WorkspaceEdit.new(
+            changes: { @node_context.uri => edits },
+          )
+        end
+
+        # Produces a TextEdit that deletes the full source line of +node+,
+        # including its trailing newline so no blank line is left behind.
+        #
+        # @param node [Prism::Node]
+        # @return [Interface::TextEdit]
+        def delete_line_edit(node)
+          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),
+            ),
+            new_text: "",
+          )
+        end
+
+        # Leading whitespace for the line that contains +node+.
+        #
+        # @param node [Prism::Node]
+        # @return [String]
+        def indent_for(node)
+          " " * node.location.start_column
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/test_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/internal"
+require "ruby_lsp/ruby_lsp_refactor/addon"
+
+module RubyLsp
+  module Refactor
+    # TestHelper provides lightweight integration scaffolding for testing
+    # ruby-lsp-refactor listeners without spinning up a full LSP server.
+    #
+    # Usage in a Minitest test class:
+    #
+    #   class MyTest < Minitest::Test
+    #     include RubyLsp::Refactor::TestHelper
+    #
+    #     def test_something
+    #       actions = code_actions_for(source, line: 0)
+    #       assert_includes actions.map(&:title), "Convert to post-conditional"
+    #     end
+    #   end
+    module TestHelper
+      # Parses +source+, runs the full listener pipeline via
+      # Addon.refactor_actions_for, and returns the resulting code actions.
+      # This exercises exactly the same path that runs inside the real LSP server.
+      #
+      # @param source [String]  Ruby source code to analyse.
+      # @param line   [Integer] Zero-based line the cursor is on.
+      # @param char   [Integer] Zero-based character offset (column).
+      # @return [Array<Interface::CodeAction>]
+      def code_actions_for(source, line: 0, char: 0)
+        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,
+        )
+
+        # LSP range hash — same shape the real server passes to CodeActions.
+        range = {
+          start: { line: line, character: char },
+          end:   { line: line, character: char },
+        }
+
+        RubyLsp::Refactor::Addon.refactor_actions_for(document, range)
+      end
+    end
+  end
+end

data/sig/ruby/lsp/refactor.rbs

@@ -0,0 +1,8 @@
+module Ruby
+  module Lsp
+    module Refactor
+      VERSION: String
+      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+    end
+  end
+end

data/test/ruby_lsp_refactor/array_listener_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "ruby_lsp/test_helper"
+
+module RubyLsp
+  module Refactor
+    class ArrayListenerTest < 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_symbol_array_to_percent_i
+        source = "[:foo, :bar, :baz]\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to symbol array")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_equal "%i[foo bar baz]", edit.new_text
+      end
+
+      def test_converts_single_element_symbol_array
+        source = "[:only]\n"
+        actions = code_actions_for(source, line: 0)
+        action  = find_action(actions, "Convert to symbol array")
+        refute_nil action
+
+        edit = single_edit(action)
+        assert_equal "%i[only]", edit.new_text
+      end
+
+      # ---------------------------------------------------------------------------
+      # Negative cases
+      # ---------------------------------------------------------------------------
+
+      def test_does_not_offer_action_for_mixed_array
+        source = "[:foo, 'bar']\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to symbol array")
+      end
+
+      def test_does_not_offer_action_for_empty_array
+        source = "[]\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to symbol array")
+      end
+
+      def test_does_not_offer_action_for_already_percent_i
+        source = "%i[foo bar]\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to symbol array")
+      end
+
+      def test_does_not_offer_action_for_integer_array
+        source = "[1, 2, 3]\n"
+        actions = code_actions_for(source, line: 0)
+        assert_nil find_action(actions, "Convert to symbol array")
+      end
+
+      # ---------------------------------------------------------------------------
+      # Resilience
+      # ---------------------------------------------------------------------------
+
+      def test_does_not_raise_on_empty_source
+        assert_silent { code_actions_for("", line: 0) }
+      end
+    end
+  end
+end