ruby-lsp-refactor 0.1.0

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

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Handles all conditional-related code actions by listening to IfNode and
+    # UnlessNode events from the Prism dispatcher.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Convert to post-conditional
+    #      if cond          →   body if cond
+    #        body
+    #      end
+    #
+    # 2. Convert to block if / block unless
+    #      body if cond     →   if cond
+    #                             body
+    #                           end
+    #
+    # 3. Toggle if ↔ unless
+    #      if cond  →  unless cond   (and vice-versa, no else/elsif)
+    #
+    # 4. Invert if/else
+    #      if cond          →   if !cond
+    #        then_body            else_body
+    #      else             →   else
+    #        else_body            then_body
+    #      end              →   end
+    class ConditionalListener
+      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_if_node_enter, :on_unless_node_enter)
+      end
+
+      # ── dispatcher callbacks ────────────────────────────────────────────────
+
+      def on_if_node_enter(node)
+        return unless node_covers_cursor?(node)
+
+        emit_to_post_conditional(node)  if block_if_convertible_to_post?(node)
+        emit_to_block_if(node)          if post_if_convertible_to_block?(node)
+        emit_toggle_to_unless(node)     if toggleable_if?(node)
+        emit_invert_if_else(node)       if invertible_if_else?(node)
+      rescue StandardError
+        nil
+      end
+
+      def on_unless_node_enter(node)
+        return unless node_covers_cursor?(node)
+
+        emit_to_post_unless(node)   if block_unless_convertible_to_post?(node)
+        emit_to_block_unless(node)  if post_unless_convertible_to_block?(node)
+        emit_toggle_to_if(node)     if toggleable_unless?(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # ── predicate helpers ───────────────────────────────────────────────────
+
+      # block `if` with a single-statement body and no else/elsif
+      def block_if_convertible_to_post?(node)
+        node.end_keyword_loc &&
+          node.subsequent.nil? &&
+          node.statements&.body&.length == 1
+      end
+
+      # post-conditional `if` (no `end` keyword)
+      def post_if_convertible_to_block?(node)
+        node.end_keyword_loc.nil?
+      end
+
+      # block `if` with no else/elsif — can flip to `unless`
+      def toggleable_if?(node)
+        node.end_keyword_loc && node.subsequent.nil?
+      end
+
+      # block `if` with exactly one else branch (no elsif) — can invert
+      def invertible_if_else?(node)
+        node.end_keyword_loc &&
+          node.subsequent.is_a?(Prism::ElseNode) &&
+          node.statements&.body&.length&.positive? &&
+          node.subsequent.statements&.body&.length&.positive?
+      end
+
+      # block `unless` with a single-statement body and no else
+      def block_unless_convertible_to_post?(node)
+        node.end_keyword_loc &&
+          unless_else_clause(node).nil? &&
+          node.statements&.body&.length == 1
+      end
+
+      # post-conditional `unless` (no `end` keyword)
+      def post_unless_convertible_to_block?(node)
+        node.end_keyword_loc.nil?
+      end
+
+      # block `unless` with no else — can flip to `if`
+      def toggleable_unless?(node)
+        node.end_keyword_loc && unless_else_clause(node).nil?
+      end
+
+      # `UnlessNode#consequent` is deprecated in Prism >= 1.x; use `else_clause`.
+      def unless_else_clause(node)
+        node.respond_to?(:else_clause) ? node.else_clause : node.consequent
+      end
+
+      # ── emitters ────────────────────────────────────────────────────────────
+
+      # 1a. block if → post-conditional if
+      def emit_to_post_conditional(node)
+        indent   = indent_for(node)
+        cond_src = node.predicate.location.slice.strip
+        body_src = node.statements.body.first.location.slice.strip
+        new_text = "#{indent}#{body_src} if #{cond_src}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to post-conditional",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # 1b. block unless → post-conditional unless
+      def emit_to_post_unless(node)
+        indent   = indent_for(node)
+        cond_src = node.predicate.location.slice.strip
+        body_src = node.statements.body.first.location.slice.strip
+        new_text = "#{indent}#{body_src} unless #{cond_src}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to post-conditional",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # 2a. post-conditional if → block if
+      def emit_to_block_if(node)
+        indent   = indent_for(node)
+        cond_src = node.predicate.location.slice.strip
+        body_src = node.statements.body.first.location.slice.strip
+        new_text = "#{indent}if #{cond_src}\n#{indent}  #{body_src}\n#{indent}end"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to block if",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # 2b. post-conditional unless → block unless
+      def emit_to_block_unless(node)
+        indent   = indent_for(node)
+        cond_src = node.predicate.location.slice.strip
+        body_src = node.statements.body.first.location.slice.strip
+        new_text = "#{indent}unless #{cond_src}\n#{indent}  #{body_src}\n#{indent}end"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to block unless",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # 3a. if → unless  (strips leading `!` from predicate when present)
+      def emit_toggle_to_unless(node)
+        indent   = indent_for(node)
+        cond_src = stripped_negation(node.predicate)
+        body_src = node.statements.body.map { |s| "#{indent}  #{s.location.slice.strip}" }.join("\n")
+        new_text = "#{indent}unless #{cond_src}\n#{body_src}\n#{indent}end"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to unless",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # 3b. unless → if  (strips leading `!` from predicate when present)
+      def emit_toggle_to_if(node)
+        indent   = indent_for(node)
+        cond_src = stripped_negation(node.predicate)
+        body_src = node.statements.body.map { |s| "#{indent}  #{s.location.slice.strip}" }.join("\n")
+        new_text = "#{indent}if #{cond_src}\n#{body_src}\n#{indent}end"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to if",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # 4. Invert if/else — swap branches, negate predicate
+      def emit_invert_if_else(node)
+        indent    = indent_for(node)
+        cond_src  = negated_predicate(node.predicate)
+        then_body = node.statements.body.map { |s| "#{indent}  #{s.location.slice.strip}" }.join("\n")
+        else_body = node.subsequent.statements.body.map { |s| "#{indent}  #{s.location.slice.strip}" }.join("\n")
+        new_text  = "#{indent}if #{cond_src}\n#{else_body}\n#{indent}else\n#{then_body}\n#{indent}end"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Invert if/else",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # ── predicate negation helpers ──────────────────────────────────────────
+
+      # Returns the source of the predicate with a leading `!` stripped.
+      # If the predicate is not a `!` call, returns it unchanged (used for
+      # toggle: `if !x` → `unless x`, `unless !x` → `if x`).
+      def stripped_negation(predicate)
+        if bang_call?(predicate)
+          predicate.receiver.location.slice.strip
+        else
+          predicate.location.slice.strip
+        end
+      end
+
+      # Returns a negated form of the predicate source:
+      #   - `!x`  → `x`   (double-negation cancels)
+      #   - `x`   → `!x`
+      def negated_predicate(predicate)
+        if bang_call?(predicate)
+          predicate.receiver.location.slice.strip
+        else
+          "!#{predicate.location.slice.strip}"
+        end
+      end
+
+      # Returns true when +node+ is a `!` unary call (CallNode with name :!).
+      def bang_call?(node)
+        node.is_a?(Prism::CallNode) && node.name == :! && node.receiver
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Emits a "Convert to keyword syntax" code action when the cursor is on a
+    # HashNode (or a keyword-argument hash) that contains at least one
+    # hash-rocket pair whose key is a simple symbol.
+    #
+    # Input:   { :foo => 1, :bar => "x" }
+    # Output:  { foo: 1, bar: "x" }
+    #
+    # Pairs whose key is NOT a plain symbol (e.g. string keys, computed keys,
+    # or keys that are already in keyword syntax) are left unchanged.
+    class HashListener
+      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_hash_node_enter, :on_keyword_hash_node_enter)
+      end
+
+      def on_hash_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless has_rocket_pairs?(node.elements)
+
+        emit_convert_hash(node, node.elements)
+      rescue StandardError
+        nil
+      end
+
+      # keyword_hash_node appears in method call arguments: foo(:a => 1)
+      def on_keyword_hash_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless has_rocket_pairs?(node.elements)
+
+        emit_convert_hash(node, node.elements)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Returns true when at least one AssocNode uses a hash-rocket operator
+      # and has a plain SymbolNode key.
+      def has_rocket_pairs?(elements)
+        elements.any? { |el| rocket_assoc?(el) }
+      end
+
+      # An AssocNode is a rocket pair when it has an operator_loc (the `=>`).
+      def rocket_assoc?(el)
+        el.is_a?(Prism::AssocNode) &&
+          el.operator_loc &&
+          el.key.is_a?(Prism::SymbolNode) &&
+          el.key.opening_loc&.slice == ":"
+      end
+
+      def emit_convert_hash(node, elements)
+        new_pairs = elements.map { |el| convert_element(el) }
+
+        # Reconstruct the hash preserving the outer braces when present.
+        # HashNode has opening/closing braces; KeywordHashNode does not.
+        if node.is_a?(Prism::HashNode)
+          new_text = "{ #{new_pairs.join(", ")} }"
+        else
+          new_text = new_pairs.join(", ")
+        end
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to keyword syntax",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+
+      # Converts a single hash element to its string representation.
+      # Rocket pairs with symbol keys become `key: value`; everything else
+      # is reproduced verbatim from the source.
+      def convert_element(el)
+        if rocket_assoc?(el)
+          key_name  = el.key.unescaped
+          value_src = el.value.location.slice.strip
+          "#{key_name}: #{value_src}"
+        else
+          el.location.slice.strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Handles method-level structural refactors.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Extract to method
+    #      Cursor on a LocalVariableWriteNode inside a def body.
+    #      Extracts the assignment RHS (and the assignment itself) into a new
+    #      private method, passing any variables that are defined before the
+    #      extraction point and referenced inside the extracted expression as
+    #      parameters.
+    #
+    # 2. Add parameter
+    #      Cursor anywhere inside a DefNode.
+    #      Appends a `new_param` placeholder at the end of the parameter list
+    #      (or creates parentheses if the method has none).
+    #
+    # 3. Convert to keyword arguments
+    #      Cursor anywhere inside a DefNode that has required positional params.
+    #      Rewrites `def foo(a, b)` → `def foo(a:, b:)` and updates every
+    #      call-site within the same file that passes positional arguments.
+    #
+    # 4. Extract to let  (RSpec)
+    #      Cursor on a LocalVariableWriteNode inside an RSpec `it`/`specify`
+    #      block.  Moves the assignment into a `let(:name) { value }` block
+    #      inserted above the enclosing example group call.
+    class MethodListener
+      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
+
+        # Accumulate ancestor context during the single-pass walk.
+        # Each entry is a Hash with :type and the node itself.
+        @ancestor_stack = []
+
+        # All write nodes seen so far (for "defined before extraction point").
+        @seen_writes = []
+
+        dispatcher.register(
+          self,
+          :on_def_node_enter,
+          :on_def_node_leave,
+          :on_call_node_enter,
+          :on_call_node_leave,
+          :on_local_variable_write_node_enter,
+        )
+      end
+
+      # ── dispatcher callbacks ────────────────────────────────────────────────
+
+      # Push def onto the ancestor stack; also emit parameter actions when the
+      # cursor is inside this def.
+      def on_def_node_enter(node)
+        @ancestor_stack.push({ type: :def, node: node })
+
+        return unless node_covers_cursor?(node)
+
+        emit_add_parameter(node)
+        emit_convert_to_kwargs(node) if has_positional_params?(node)
+      rescue StandardError
+        nil
+      end
+
+      def on_def_node_leave(_node)
+        @ancestor_stack.pop
+        @seen_writes.clear
+      rescue StandardError
+        nil
+      end
+
+      def on_call_node_enter(node)
+        @ancestor_stack.push({ type: :call, node: node }) if rspec_example?(node)
+      rescue StandardError
+        nil
+      end
+
+      def on_call_node_leave(node)
+        @ancestor_stack.pop if rspec_example?(node)
+      rescue StandardError
+        nil
+      end
+
+      def on_local_variable_write_node_enter(node)
+        enclosing_def  = nearest_ancestor(:def)
+        enclosing_call = nearest_ancestor(:call)
+
+        # Always track writes for param-detection, regardless of cursor position.
+        @seen_writes << node
+
+        return unless node_covers_cursor?(node)
+
+        if enclosing_call && rspec_example?(enclosing_call[:node])
+          emit_extract_to_let(node, enclosing_call[:node])
+        elsif enclosing_def
+          emit_extract_to_method(node, enclosing_def[:node])
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # ── ancestor helpers ────────────────────────────────────────────────────
+
+      def nearest_ancestor(type)
+        @ancestor_stack.reverse.find { |a| a[:type] == type }
+      end
+
+      # ── 1. Extract to method ─────────────────────────────────────────────────
+
+      def emit_extract_to_method(write_node, def_node)
+        method_name = write_node.name.to_s
+        rhs_src     = write_node.value.location.slice.strip
+        indent      = indent_for(def_node)
+        body_indent = "#{indent}  "
+
+        # Determine which variables defined before this write are referenced
+        # inside the RHS expression.
+        params = params_needed_for(write_node.value, def_node)
+        param_list = params.empty? ? "" : "(#{params.join(", ")})"
+        call_args  = params.empty? ? "" : "(#{params.join(", ")})"
+
+        # Replace the assignment RHS with a call to the new method.
+        replace_edit = Interface::TextEdit.new(
+          range:    node_to_lsp_range(write_node.value),
+          new_text: "#{method_name}#{call_args}",
+        )
+
+        # Insert the new private method after the enclosing def's closing `end`.
+        insert_line = def_node.location.end_line  # 1-based; insert after this line
+        new_method  = "\n#{body_indent}private\n\n" \
+                      "#{body_indent}def #{method_name}#{param_list}\n" \
+                      "#{body_indent}  #{rhs_src}\n" \
+                      "#{body_indent}end\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: new_method,
+        )
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Extract to method '#{method_name}'",
+          kind:  Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit:  multi_edit_workspace_edit([replace_edit, insert_edit]),
+        )
+      end
+
+      # Collect names of variables that are:
+      #   a) written before the extraction point in the same def body, AND
+      #   b) referenced (read) inside +expr_node+.
+      def params_needed_for(expr_node, def_node)
+        expr_src = expr_node.location.slice
+
+        @seen_writes
+          .select { |w| w.location.start_offset < expr_node.location.start_offset }
+          .map { |w| w.name.to_s }
+          .select { |name| expr_src.match?(/\b#{Regexp.escape(name)}\b/) }
+          .uniq
+      end
+
+      # ── 2. Add parameter ─────────────────────────────────────────────────────
+
+      def emit_add_parameter(def_node)
+        if def_node.parameters
+          # Append after the last existing parameter.
+          last_param = last_parameter(def_node.parameters)
+          insert_col = last_param.location.end_column
+          insert_line = last_param.location.end_line - 1
+          new_text_fragment = ", new_param"
+
+          edit = Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: insert_line, character: insert_col),
+              end:   Interface::Position.new(line: insert_line, character: insert_col),
+            ),
+            new_text: new_text_fragment,
+          )
+        else
+          # No parameters yet — insert `(new_param)` right after the method name.
+          name_end_col  = def_node.name_loc.end_column
+          name_end_line = def_node.name_loc.end_line - 1
+
+          edit = Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(line: name_end_line, character: name_end_col),
+              end:   Interface::Position.new(line: name_end_line, character: name_end_col),
+            ),
+            new_text: "(new_param)",
+          )
+        end
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Add parameter",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  multi_edit_workspace_edit([edit]),
+        )
+      end
+
+      # Returns the last leaf parameter node from a ParametersNode.
+      def last_parameter(params_node)
+        [
+          params_node.requireds,
+          params_node.optionals,
+          params_node.keywords,
+          [params_node.rest, params_node.keyword_rest, params_node.block].compact,
+        ].flatten.compact.last
+      end
+
+      # ── 3. Convert to keyword arguments ──────────────────────────────────────
+
+      def has_positional_params?(def_node)
+        def_node.parameters&.requireds&.any? { |p| p.is_a?(Prism::RequiredParameterNode) }
+      end
+
+      def emit_convert_to_kwargs(def_node)
+        params_node = def_node.parameters
+        requireds   = params_node.requireds.select { |p| p.is_a?(Prism::RequiredParameterNode) }
+
+        # Build the new parameter list: keep non-required params verbatim,
+        # convert required positionals to `name:`.
+        all_params = build_kwargs_param_list(params_node, requireds)
+        new_params = all_params.join(", ")
+
+        # Replace the entire parameters span (between the parens).
+        params_range = Interface::Range.new(
+          start: Interface::Position.new(
+            line:      params_node.location.start_line - 1,
+            character: params_node.location.start_column,
+          ),
+          end: Interface::Position.new(
+            line:      params_node.location.end_line - 1,
+            character: params_node.location.end_column,
+          ),
+        )
+
+        edit = Interface::TextEdit.new(range: params_range, new_text: new_params)
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to keyword arguments",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  multi_edit_workspace_edit([edit]),
+        )
+      end
+
+      def build_kwargs_param_list(params_node, requireds)
+        required_names = requireds.map(&:name)
+        parts = []
+
+        params_node.requireds.each do |p|
+          if required_names.include?(p.name)
+            parts << "#{p.name}:"
+          else
+            parts << p.location.slice.strip
+          end
+        end
+
+        params_node.optionals.each { |p| parts << p.location.slice.strip }
+        parts << params_node.rest.location.slice.strip   if params_node.rest
+        params_node.keywords.each  { |p| parts << p.location.slice.strip }
+        parts << params_node.keyword_rest.location.slice.strip if params_node.keyword_rest
+        parts << params_node.block.location.slice.strip        if params_node.block
+
+        parts
+      end
+
+      # ── 4. Extract to let (RSpec) ─────────────────────────────────────────────
+
+      RSPEC_EXAMPLE_METHODS = %i[it specify example scenario].freeze
+
+      def rspec_example?(call_node)
+        RSPEC_EXAMPLE_METHODS.include?(call_node.name) && call_node.block
+      end
+
+      def emit_extract_to_let(write_node, example_call_node)
+        var_name = write_node.name.to_s
+        rhs_src  = write_node.value.location.slice.strip
+        indent   = indent_for(example_call_node)
+
+        # Insert `let(:name) { value }` on the line before the example call.
+        insert_line = example_call_node.location.start_line - 1
+        let_text    = "#{indent}let(:#{var_name}) { #{rhs_src} }\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: let_text,
+        )
+
+        # Delete the original assignment line inside the example.
+        delete_edit = delete_line_edit(write_node)
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Extract to let(:#{var_name})",
+          kind:  Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit:  multi_edit_workspace_edit([insert_edit, delete_edit]),
+        )
+      end
+    end
+  end
+end