ruby-lsp-refactor 0.1.0 → 0.1.1

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Detects common Enumerable method-chain patterns and offers a single
+    # collapsed replacement.
+    #
+    # Emitted actions
+    # ───────────────
+    # 1. map + flatten(1) / flatten  →  flat_map
+    #      items.map { |i| i.tags }.flatten(1)  →  items.flat_map { |i| i.tags }
+    #
+    # 2. select + first  →  find
+    #      users.select { |u| u.admin? }.first  →  users.find { |u| u.admin? }
+    #
+    # 3. map + compact  →  filter_map
+    #      items.map { |i| i.value }.compact  →  items.filter_map { |i| i.value }
+    #
+    # All three patterns share the same structure:
+    #   outer_call( receiver: inner_call( block: BlockNode ) )
+    # where outer_call has no block of its own.
+    class EnumerableListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      # { outer_method => { inner_method => replacement } }
+      PATTERNS = {
+        flatten: { map: "flat_map" },
+        first: { select: "find" },
+        compact: { map: "filter_map" }
+      }.freeze
+
+      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 if node.block # outer call must not have its own block
+
+        outer_name = node.name
+        return unless PATTERNS.key?(outer_name)
+
+        # flatten is only eligible when called with no args or with arg `1`.
+        return if outer_name == :flatten && !flatten_eligible?(node)
+
+        inner = node.receiver
+        return unless inner.is_a?(Prism::CallNode) && inner.block.is_a?(Prism::BlockNode)
+
+        replacement = PATTERNS[outer_name][inner.name]
+        return unless replacement
+
+        emit_collapse(node, inner, replacement)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # flatten() and flatten(1) are eligible; flatten(2+) changes semantics.
+      def flatten_eligible?(node)
+        args = node.arguments&.arguments
+        return true if args.nil? || args.empty?
+        return true if args.length == 1 && args.first.is_a?(Prism::IntegerNode) &&
+                       args.first.location.slice == "1"
+
+        false
+      end
+
+      def emit_collapse(outer_node, inner_node, replacement)
+        # Reconstruct: <receiver>.<replacement> <block>
+        receiver_src = inner_node.receiver.location.slice.strip
+        block_src    = inner_node.block.location.slice.strip
+
+        new_text = "#{indent_for(outer_node)}#{receiver_src}.#{replacement} #{block_src}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to .#{replacement}",
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(outer_node, new_text)
+        )
+      end
+    end
+  end
+end

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

@@ -67,16 +67,16 @@ module RubyLsp
 
         # 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
+        new_text = if node.is_a?(Prism::HashNode)
+                     "{ #{new_pairs.join(", ")} }"
+                   else
+                     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),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: single_edit_workspace_edit(node, new_text)
         )
       end
 

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Toggles between symbolic and word forms of logical operators.
+    #
+    # Emitted actions
+    # ───────────────
+    # AndNode:
+    #   user.valid? && user.save   →   user.valid? and user.save
+    #   user.valid? and user.save  →   user.valid? && user.save
+    #
+    # OrNode:
+    #   a || b   →   a or b
+    #   a or b   →   a || b
+    class LogicalOperatorListener
+      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_and_node_enter, :on_or_node_enter)
+      end
+
+      def on_and_node_enter(node)
+        return unless node_covers_cursor?(node)
+
+        if node.operator_loc.slice == "&&"
+          emit_toggle(node, "&&", "and")
+        else
+          emit_toggle(node, "and", "&&")
+        end
+      rescue StandardError
+        nil
+      end
+
+      def on_or_node_enter(node)
+        return unless node_covers_cursor?(node)
+
+        if node.operator_loc.slice == "||"
+          emit_toggle(node, "||", "or")
+        else
+          emit_toggle(node, "or", "||")
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def emit_toggle(node, from_op, to_op)
+        left_src  = node.left.location.slice.strip
+        right_src = node.right.location.slice.strip
+        new_text  = "#{indent_for(node)}#{left_src} #{to_op} #{right_src}"
+
+        title = "Convert '#{from_op}' to '#{to_op}'"
+
+        @response_builder << Interface::CodeAction.new(
+          title: title,
+          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/method_listener.rb

@@ -53,7 +53,7 @@ module RubyLsp
           :on_def_node_leave,
           :on_call_node_enter,
           :on_call_node_leave,
-          :on_local_variable_write_node_enter,
+          :on_local_variable_write_node_enter
         )
       end
 
@@ -133,12 +133,12 @@ module RubyLsp
 
         # 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}",
+          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
+        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" \
@@ -147,22 +147,22 @@ module RubyLsp
         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),
+            end: Interface::Position.new(line: insert_line, character: 0)
           ),
-          new_text: new_method,
+          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]),
+          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)
+      def params_needed_for(expr_node, _def_node)
         expr_src = expr_node.location.slice
 
         @seen_writes
@@ -185,9 +185,9 @@ module RubyLsp
           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),
+              end: Interface::Position.new(line: insert_line, character: insert_col)
             ),
-            new_text: new_text_fragment,
+            new_text: new_text_fragment
           )
         else
           # No parameters yet — insert `(new_param)` right after the method name.
@@ -197,16 +197,16 @@ module RubyLsp
           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),
+              end: Interface::Position.new(line: name_end_line, character: name_end_col)
             ),
-            new_text: "(new_param)",
+            new_text: "(new_param)"
           )
         end
 
         @response_builder << Interface::CodeAction.new(
           title: "Add parameter",
-          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
-          edit:  multi_edit_workspace_edit([edit]),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: multi_edit_workspace_edit([edit])
         )
       end
 
@@ -216,7 +216,7 @@ module RubyLsp
           params_node.requireds,
           params_node.optionals,
           params_node.keywords,
-          [params_node.rest, params_node.keyword_rest, params_node.block].compact,
+          [params_node.rest, params_node.keyword_rest, params_node.block].compact
         ].flatten.compact.last
       end
 
@@ -238,21 +238,21 @@ module RubyLsp
         # 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,
+            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,
-          ),
+            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]),
+          kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit: multi_edit_workspace_edit([edit])
         )
       end
 
@@ -261,16 +261,16 @@ module RubyLsp
         parts = []
 
         params_node.requireds.each do |p|
-          if required_names.include?(p.name)
-            parts << "#{p.name}:"
-          else
-            parts << p.location.slice.strip
-          end
+          parts << if required_names.include?(p.name)
+                     "#{p.name}:"
+                   else
+                     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.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
 
@@ -297,9 +297,9 @@ module RubyLsp
         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),
+            end: Interface::Position.new(line: insert_line, character: 0)
           ),
-          new_text: let_text,
+          new_text: let_text
         )
 
         # Delete the original assignment line inside the example.
@@ -307,8 +307,8 @@ module RubyLsp
 
         @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]),
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit: multi_edit_workspace_edit([insert_edit, delete_edit])
         )
       end
     end

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