ruby-lsp-refactor 0.1.1 → 0.1.2

data/lib/ruby/lsp/refactor/version.rb

@@ -3,7 +3,7 @@
 module Ruby
   module Lsp
     module Refactor
-      VERSION = "0.1.1"
+      VERSION = "0.1.2"
     end
   end
 end

data/lib/ruby_lsp/ruby_lsp_refactor/addon.rb

@@ -2,27 +2,40 @@
 
 require "ruby_lsp/addon"
 
-# Phase 1 – Local rewrites
+# Conditionals
 require_relative "listeners/conditional_listener"
-require_relative "listeners/string_listener"
-require_relative "listeners/block_style_listener"
-require_relative "listeners/logical_operator_listener"
+require_relative "listeners/early_return_listener"
 
-# Phase 2 – Variable & literal optimisation
-require_relative "listeners/variable_listener"
-require_relative "listeners/hash_listener"
-require_relative "listeners/array_listener"
+# Strings
+require_relative "listeners/string_listener"
 require_relative "listeners/string_array_listener"
 require_relative "listeners/string_freeze_listener"
+
+# Collections
+require_relative "listeners/array_listener"
+require_relative "listeners/hash_listener"
 require_relative "listeners/enumerable_listener"
-require_relative "listeners/raise_listener"
 
-# Phase 3 – Advanced structure
-require_relative "listeners/method_listener"
+# Variables & constants
+require_relative "listeners/variable_listener"
 require_relative "listeners/constant_listener"
+
+# Methods & classes
+require_relative "listeners/method_listener"
+require_relative "listeners/extract_predicate_listener"
 require_relative "listeners/accessor_listener"
 require_relative "listeners/rescue_listener"
 require_relative "listeners/super_listener"
+
+# Multi-file
+require_relative "listeners/extract_include_file_listener"
+
+# Operators & blocks
+require_relative "listeners/tap_listener"
+require_relative "listeners/logical_operator_listener"
+require_relative "listeners/raise_listener"
+
+# RSpec
 require_relative "listeners/rspec_let_listener"
 
 module RubyLsp
@@ -90,27 +103,25 @@ module RubyLsp
         response_builder = RubyLsp::ResponseBuilders::CollectionResponseBuilder.new
         dispatcher       = Prism::Dispatcher.new
 
-        # Phase 1 – Local rewrites
         ConditionalListener.new(response_builder, node_context, dispatcher)
+        EarlyReturnListener.new(response_builder, node_context, dispatcher)
         StringListener.new(response_builder, node_context, dispatcher)
-        BlockStyleListener.new(response_builder, node_context, dispatcher)
-        LogicalOperatorListener.new(response_builder, node_context, dispatcher)
-
-        # Phase 2 – Variable & literal optimisation
-        VariableListener.new(response_builder, node_context, dispatcher)
-        HashListener.new(response_builder, node_context, dispatcher)
-        ArrayListener.new(response_builder, node_context, dispatcher)
         StringArrayListener.new(response_builder, node_context, dispatcher)
         StringFreezeListener.new(response_builder, node_context, dispatcher)
+        ArrayListener.new(response_builder, node_context, dispatcher)
+        HashListener.new(response_builder, node_context, dispatcher)
         EnumerableListener.new(response_builder, node_context, dispatcher)
-        RaiseListener.new(response_builder, node_context, dispatcher)
-
-        # Phase 3 – Advanced structure
-        MethodListener.new(response_builder, node_context, dispatcher)
+        VariableListener.new(response_builder, node_context, dispatcher)
         ConstantListener.new(response_builder, node_context, dispatcher)
+        MethodListener.new(response_builder, node_context, dispatcher)
+        ExtractPredicateListener.new(response_builder, node_context, dispatcher)
         AccessorListener.new(response_builder, node_context, dispatcher)
         RescueListener.new(response_builder, node_context, dispatcher)
         SuperListener.new(response_builder, node_context, dispatcher)
+        ExtractIncludeFileListener.new(response_builder, node_context, dispatcher)
+        TapListener.new(response_builder, node_context, dispatcher)
+        LogicalOperatorListener.new(response_builder, node_context, dispatcher)
+        RaiseListener.new(response_builder, node_context, dispatcher)
         RspecLetListener.new(response_builder, node_context, dispatcher)
 
         dispatcher.dispatch(document.ast)

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Convert to early return" when the cursor is on a guard `if` block
+    # that is the first statement in a method body and has no `else` branch.
+    #
+    # From "Prefer early returns" in Refactoring Rails: replace a top-level
+    # guard `if` with `return unless` so the happy path is not nested.
+    #
+    # Input (cursor on the `if` line):
+    #   def charge_purchase(order)
+    #     if order.fulfilled?
+    #       OrderChargeConfirmation.new(order).create!
+    #     end
+    #   end
+    #
+    # Output:
+    #   def charge_purchase(order)
+    #     return unless order.fulfilled?
+    #     OrderChargeConfirmation.new(order).create!
+    #   end
+    #
+    # Eligibility:
+    #   - Block-form `if` (has end_keyword_loc) with no else/elsif.
+    #   - Must be the first statement in the enclosing method body.
+    #   - Body may contain one or more statements.
+    class EarlyReturnListener
+      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_if_node_enter
+        )
+      end
+
+      def on_def_node_enter(node)
+        @current_def = node
+      rescue StandardError
+        nil
+      end
+
+      def on_def_node_leave(_node)
+        @current_def = nil
+      rescue StandardError
+        nil
+      end
+
+      def on_if_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless eligible?(node)
+
+        emit_early_return(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def eligible?(node)
+        return false unless node.end_keyword_loc # block-form only
+        return false if node.subsequent # no else/elsif
+        return false unless node.statements&.body&.any?
+        return false unless first_statement_in_def?(node)
+
+        true
+      end
+
+      def first_statement_in_def?(if_node)
+        return false unless @current_def
+
+        body = @current_def.body
+        return false unless body.is_a?(Prism::StatementsNode)
+
+        body.body.first.equal?(if_node)
+      end
+
+      def emit_early_return(node)
+        indent     = indent_for(node)
+        cond_src   = node.predicate.location.slice.strip
+        body_lines = node.statements.body
+                         .map { |s| "#{indent}#{s.location.slice.strip}" }
+                         .join("\n")
+
+        new_text = "#{indent}return unless #{cond_src}\n#{body_lines}"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to early return",
+          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/extract_include_file_listener.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Extract to include file" when the cursor is on a ModuleNode or
+    # ClassNode that coexists with other top-level statements in the same file.
+    #
+    # The action:
+    #   1. Creates a new file named after the module/class (snake_case) in the
+    #      same directory as the source file.
+    #   2. Writes the extracted node's source into the new file, prefixed with
+    #      the standard `# frozen_string_literal: true` magic comment.
+    #   3. Replaces the extracted node in the source file with a
+    #      `require_relative` statement.
+    #
+    # This uses `document_changes` (not `changes`) in the WorkspaceEdit so
+    # that the LSP client can handle the CreateFile resource operation.
+    #
+    # Input (cursor on the module, file also contains User class):
+    #   # app/models/user.rb
+    #   module Greetable
+    #     def greet = "hello"
+    #   end
+    #
+    #   class User
+    #     include Greetable
+    #   end
+    #
+    # Output:
+    #   # app/models/greetable.rb  (new file)
+    #   # frozen_string_literal: true
+    #
+    #   module Greetable
+    #     def greet = "hello"
+    #   end
+    #
+    #   # app/models/user.rb  (modified)
+    #   require_relative "greetable"
+    #
+    #   class User
+    #     include Greetable
+    #   end
+    class ExtractIncludeFileListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder  = response_builder
+        @node_context      = node_context
+        @top_level_count   = 0
+
+        dispatcher.register(
+          self,
+          :on_program_node_enter,
+          :on_module_node_enter,
+          :on_class_node_enter
+        )
+      end
+
+      # Count top-level statements so we know whether extraction is meaningful.
+      def on_program_node_enter(node)
+        @top_level_count = node.statements.body.length
+      rescue StandardError
+        nil
+      end
+
+      def on_module_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless top_level_node?(node)
+        return unless @top_level_count > 1
+
+        emit_extract(node, module_name(node))
+      rescue StandardError
+        nil
+      end
+
+      def on_class_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless top_level_node?(node)
+        return unless @top_level_count > 1
+
+        emit_extract(node, class_name(node))
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # A node is top-level when its start column is 0 (not nested inside
+      # another class/module).
+      def top_level_node?(node)
+        node.location.start_column.zero?
+      end
+
+      def module_name(node)
+        node.constant_path.location.slice
+      end
+
+      def class_name(node)
+        node.constant_path.location.slice
+      end
+
+      def emit_extract(node, const_name)
+        source_uri_str = @node_context.uri
+        new_uri_str    = new_file_uri(source_uri_str, const_name)
+        require_name   = snake_case(const_name)
+        node_src       = node.location.slice
+
+        # ── 1. Create the new file ──────────────────────────────────────────
+        create_op = create_file_operation(new_uri_str)
+
+        # ── 2. Write the extracted source into the new file ─────────────────
+        new_file_content = "# frozen_string_literal: true\n\n#{node_src}\n"
+        write_new_file   = text_document_edit(
+          new_uri_str,
+          [
+            Interface::TextEdit.new(
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: 0, character: 0),
+                end: Interface::Position.new(line: 0, character: 0)
+              ),
+              new_text: new_file_content
+            )
+          ]
+        )
+
+        # ── 3. Replace the node in the source file with require_relative ────
+        # Include a trailing newline so the surrounding code stays clean.
+        require_text   = "require_relative \"#{require_name}\"\n"
+        replace_in_src = text_document_edit(
+          source_uri_str,
+          [
+            Interface::TextEdit.new(
+              range: node_to_lsp_range(node),
+              new_text: require_text
+            )
+          ]
+        )
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Extract to include file \"#{require_name}.rb\"",
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit: multi_file_workspace_edit([create_op, write_new_file, replace_in_src])
+        )
+      end
+
+      # Derives the URI for the new file from the source file's URI and the
+      # constant name.  The new file is placed in the same directory.
+      def new_file_uri(source_uri_str, const_name)
+        filename   = "#{snake_case(const_name)}.rb"
+        source_uri = URI(source_uri_str)
+        source_dir = File.dirname(source_uri.path)
+        new_path   = File.join(source_dir, filename)
+
+        new_uri      = source_uri.dup
+        new_uri.path = new_path
+        new_uri.to_s
+      end
+
+      # Converts CamelCase to snake_case.
+      def snake_case(name)
+        name
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Offers "Extract predicate methods" when the cursor is on a compound
+    # `&&` or `||` expression that is the sole statement in a method body.
+    #
+    # From "Refactor Compound Conditionals into Methods" in Refactoring Rails:
+    # each operand becomes a private predicate method, making the condition
+    # self-documenting and each predicate independently testable.
+    #
+    # Input (cursor on the compound expression):
+    #   def eligible_for_return?
+    #     expired_orders.exclude?(self) && self.value > MINIMUM_RETURN_VALUE
+    #   end
+    #
+    # Output:
+    #   def eligible_for_return?
+    #     predicate_1? && predicate_2?
+    #   end
+    #
+    #   private
+    #
+    #   def predicate_1?
+    #     expired_orders.exclude?(self)
+    #   end
+    #
+    #   def predicate_2?
+    #     self.value > MINIMUM_RETURN_VALUE
+    #   end
+    #
+    # The generated names `predicate_1?` / `predicate_2?` are intentional
+    # placeholders — the developer renames them to reflect intent.
+    class ExtractPredicateListener
+      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_and_node_enter,
+          :on_or_node_enter
+        )
+      end
+
+      def on_def_node_enter(node)
+        @current_def = node
+      rescue StandardError
+        nil
+      end
+
+      def on_def_node_leave(_node)
+        @current_def = nil
+      rescue StandardError
+        nil
+      end
+
+      def on_and_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless sole_statement_in_def?(node)
+
+        emit_extract_predicates(node, "&&")
+      rescue StandardError
+        nil
+      end
+
+      def on_or_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless sole_statement_in_def?(node)
+
+        emit_extract_predicates(node, "||")
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # The compound expression must be the only statement in the method body
+      # so the replacement is unambiguous.
+      def sole_statement_in_def?(node)
+        return false unless @current_def
+
+        body = @current_def.body
+        return false unless body.is_a?(Prism::StatementsNode)
+        return false unless body.body.length == 1
+
+        body.body.first.equal?(node)
+      end
+
+      def emit_extract_predicates(node, operator)
+        def_node    = @current_def
+        indent      = indent_for(def_node)
+        body_indent = "#{indent}  "
+
+        left_src  = node.left.location.slice.strip
+        right_src = node.right.location.slice.strip
+
+        # Replace the compound expression with calls to the two new predicates.
+        replace_edit = Interface::TextEdit.new(
+          range: node_to_lsp_range(node),
+          new_text: "#{body_indent}predicate_1? #{operator} predicate_2?"
+        )
+
+        # Insert the two private predicate methods after the enclosing def.
+        insert_line = def_node.location.end_line
+        new_methods = "\n#{indent}private\n\n" \
+                      "#{indent}def predicate_1?\n" \
+                      "#{body_indent}#{left_src}\n" \
+                      "#{indent}end\n\n" \
+                      "#{indent}def predicate_2?\n" \
+                      "#{body_indent}#{right_src}\n" \
+                      "#{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_methods
+        )
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Extract predicate methods",
+          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+          edit: multi_edit_workspace_edit([replace_edit, insert_edit])
+        )
+      end
+    end
+  end
+end

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

@@ -8,27 +8,22 @@ module RubyLsp
     #
     # 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
+    # 1. 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
+    # 2. 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.
+    #      Rewrites `def foo(a, b)` → `def foo(a:, b:)`.
     #
-    # 4. Extract to let  (RSpec)
+    # 3. 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.
+    #
+    # Note: "Extract to method" is provided by ruby-lsp upstream as
+    # "Refactor: Extract Method" and is intentionally not duplicated here.
     class MethodListener
       include RubyLsp::Requests::Support::Common
       include Support::NodeHelpers
@@ -44,9 +39,6 @@ module RubyLsp
         # 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,
@@ -74,7 +66,6 @@ module RubyLsp
 
       def on_def_node_leave(_node)
         @ancestor_stack.pop
-        @seen_writes.clear
       rescue StandardError
         nil
       end
@@ -92,19 +83,11 @@ module RubyLsp
       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
+        emit_extract_to_let(node, enclosing_call[:node]) if enclosing_call && rspec_example?(enclosing_call[:node])
       rescue StandardError
         nil
       end
@@ -117,62 +100,7 @@ module RubyLsp
         @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 ─────────────────────────────────────────────────────
+      # ── 1. Add parameter ─────────────────────────────────────────────────────
 
       def emit_add_parameter(def_node)
         if def_node.parameters
@@ -220,7 +148,7 @@ module RubyLsp
         ].flatten.compact.last
       end
 
-      # ── 3. Convert to keyword arguments ──────────────────────────────────────
+      # ── 2. Convert to keyword arguments ──────────────────────────────────────
 
       def has_positional_params?(def_node)
         def_node.parameters&.requireds&.any? { |p| p.is_a?(Prism::RequiredParameterNode) }
@@ -277,7 +205,7 @@ module RubyLsp
         parts
       end
 
-      # ── 4. Extract to let (RSpec) ─────────────────────────────────────────────
+      # ── 3. Extract to let (RSpec) ─────────────────────────────────────────────
 
       RSPEC_EXAMPLE_METHODS = %i[it specify example scenario].freeze