ruby-lsp-refactor 0.1.0 → 0.1.2

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/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

@@ -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,16 +39,13 @@ 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,
           :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
 
@@ -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
@@ -185,9 +113,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 +125,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,11 +144,11 @@ 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
 
-      # ── 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) }
@@ -238,21 +166,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,23 +189,23 @@ 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
 
         parts
       end
 
-      # ── 4. Extract to let (RSpec) ─────────────────────────────────────────────
+      # ── 3. Extract to let (RSpec) ─────────────────────────────────────────────
 
       RSPEC_EXAMPLE_METHODS = %i[it specify example scenario].freeze
 
@@ -297,9 +225,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 +235,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