ruby-lsp-refactor 0.1.0 → 0.1.2

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Simplifies redundant RuntimeError raises.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Simplify raise
+    #      raise RuntimeError, "msg"   →   raise "msg"
+    #      fail  RuntimeError, "msg"   →   fail  "msg"
+    #
+    # RuntimeError is Ruby's default exception class; passing it explicitly
+    # is redundant.  Only the two-argument form (class, message) is handled —
+    # `raise RuntimeError.new("msg")` is left alone because the intent may be
+    # to call a custom initializer.
+    class RaiseListener
+      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_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless raise_or_fail?(node)
+        return unless redundant_runtime_error?(node)
+
+        emit_simplify_raise(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def raise_or_fail?(node)
+        %i[raise fail].include?(node.name)
+      end
+
+      # Returns true when the call is `raise RuntimeError, <message>` —
+      # exactly two arguments where the first is the constant RuntimeError.
+      def redundant_runtime_error?(node)
+        args = node.arguments&.arguments
+        return false unless args&.length == 2
+
+        first = args[0]
+        first.is_a?(Prism::ConstantReadNode) && first.name == :RuntimeError
+      end
+
+      def emit_simplify_raise(node)
+        keyword  = node.name.to_s # "raise" or "fail"
+        msg_src  = node.arguments.arguments[1].location.slice.strip
+        indent   = indent_for(node)
+        new_text = "#{indent}#{keyword} #{msg_src}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Simplify raise (remove redundant RuntimeError)",
+          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/rescue_listener.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Wrap body in rescue" on any DefNode whose body does not already
+    # contain a rescue clause.
+    #
+    # Input (cursor anywhere inside the def):
+    #   def call
+    #     do_thing
+    #     another_thing
+    #   end
+    #
+    # Output:
+    #   def call
+    #     do_thing
+    #     another_thing
+    #   rescue StandardError => e
+    #     raise
+    #   end
+    #
+    # The generated rescue clause uses `raise` to re-raise by default so the
+    # developer can fill in the actual error handling without accidentally
+    # swallowing exceptions.
+    class RescueListener
+      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 node.body.is_a?(Prism::StatementsNode) # already has rescue if BeginNode
+        return if node.body.body.empty?
+
+        emit_wrap_rescue(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def emit_wrap_rescue(def_node)
+        indent      = indent_for(def_node)
+        body_indent = "#{indent}  "
+
+        # Preserve the existing body lines verbatim.
+        body_src = def_node.body.body
+                           .map { |s| "#{body_indent}#{s.location.slice.strip}" }
+                           .join("\n")
+
+        # Reconstruct the full def with a rescue clause appended before `end`.
+        def_header = build_def_header(def_node)
+        new_text   = <<~RUBY.chomp
+          #{indent}#{def_header}
+          #{body_src}
+          #{body_indent}rescue StandardError => e
+          #{body_indent}  raise
+          #{indent}end
+        RUBY
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Wrap body in rescue",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(def_node, new_text)
+        )
+      end
+
+      # Reconstructs the `def name(params)` header line from the node's locations.
+      def build_def_header(node)
+        src = node.location.slice
+        # Take everything up to and including the closing paren (or method name
+        # when there are no params), stopping before the newline.
+        src.lines.first.rstrip
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Toggles between `let` and `let!` on RSpec lazy/eager memoization helpers.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Convert let → let!
+    #      let(:user) { User.new }   →   let!(:user) { User.new }
+    #
+    # 2. Convert let! → let
+    #      let!(:user) { User.new }  →   let(:user) { User.new }
+    class RspecLetListener
+      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_call_node_enter)
+      end
+
+      def on_call_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless let_call?(node)
+
+        if node.name == :let
+          emit_toggle(node, "let", "let!")
+        else
+          emit_toggle(node, "let!", "let")
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def let_call?(node)
+        %i[let let!].include?(node.name) &&
+          node.block.is_a?(Prism::BlockNode) &&
+          node.arguments&.arguments&.first.is_a?(Prism::SymbolNode)
+      end
+
+      def emit_toggle(node, from_kw, to_kw)
+        # Replace only the method name portion, preserving arguments and block.
+        src      = node.location.slice
+        new_text = "#{indent_for(node)}#{src.sub(/\A(\s*)#{Regexp.escape(from_kw)}/, "\\1#{to_kw}")}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert #{from_kw} to #{to_kw}",
+          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/string_array_listener.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Converts a bracket array of plain string literals into a %w[] word array,
+    # and vice-versa.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. Convert to string array (%w[])
+    #      ["foo", "bar", "baz"]   →   %w[foo bar baz]
+    #
+    # 2. Convert to bracket array
+    #      %w[foo bar baz]         →   ["foo", "bar", "baz"]
+    #
+    # Only plain string literals with no interpolation and no spaces in their
+    # content are eligible for compression into %w[].
+    class StringArrayListener
+      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_array_node_enter)
+      end
+
+      def on_array_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return if node.elements.empty?
+
+        if bracket_string_array?(node)
+          emit_to_percent_w(node)
+        elsif percent_w_array?(node)
+          emit_to_bracket(node)
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Returns true when every element is a plain double-quoted StringNode
+      # with no interpolation and no spaces in its content.
+      def bracket_string_array?(node)
+        return false unless node.opening_loc&.slice == "["
+
+        node.elements.all? do |el|
+          el.is_a?(Prism::StringNode) &&
+            el.opening_loc&.slice == '"' &&
+            !el.unescaped.include?(" ") &&
+            !el.unescaped.include?("\t")
+        end
+      end
+
+      # Returns true when the array uses %w[] or %W[] syntax.
+      def percent_w_array?(node)
+        opening = node.opening_loc&.slice.to_s
+        opening.start_with?("%w", "%W")
+      end
+
+      def emit_to_percent_w(node)
+        words    = node.elements.map(&:unescaped)
+        new_text = "%w[#{words.join(" ")}]"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to string array (%w[])",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
+        )
+      end
+
+      def emit_to_bracket(node)
+        words    = node.elements.map { |el| "\"#{el.unescaped}\"" }
+        new_text = "[#{words.join(", ")}]"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to bracket array",
+          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/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/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