ruby-lsp-refactor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e93bae39d557e3ff626edb5cd4465bb6ad637011f806b36900063777879f9e5d
+  data.tar.gz: a9f97f89abb0fa58a65d3fce8e451f9ee74a78bf1249f8d22045b1dffd18953b
+SHA512:
+  metadata.gz: b1ae08611fbb7d89e77fd5bad6111889317d158a79f7e1bf47d3acc229e6ed3b58c6a8ff2059359d71d614ea95b742ab40f22db7e610e36b2d3b15e9345c24a0
+  data.tar.gz: 8afd108cdaa93c2a8c17fa9ab123da4a117254d71e7044f3b2ce1f21c2649d4a3d5fc57c690be34fd1ee629b2b2d961f1157bf814c90ec4c0f0b9ff82c121fc6

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-06-15
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Aboobacker MK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,327 @@
+# ruby-lsp-refactor
+
+A [ruby-lsp](https://github.com/Shopify/ruby-lsp) add-on that provides safe,
+AST-driven refactoring code actions natively inside any LSP-supported editor
+(VS Code, Zed, Neovim, RubyMine, etc.).
+
+All refactors are powered by the [Prism](https://github.com/ruby/prism) parser
+and operate on the real AST — no regex substitutions.
+
+## Installation
+
+Add the gem to your project's `Gemfile` (it only needs to be available to the
+language server, so the `:development` group is the right place):
+
+```ruby
+group :development do
+  gem "ruby-lsp-refactor"
+end
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+The add-on is discovered and activated automatically by ruby-lsp — no further
+configuration is required.
+
+## Supported refactorings
+
+Place your cursor anywhere on the relevant construct and open the code-actions
+menu (`Cmd+.` in VS Code / Zed, or your editor's equivalent).
+
+### Phase 1 — Local rewrites
+
+#### Convert to post-conditional
+
+Collapses a single-statement `if` or `unless` block into a trailing modifier.
+
+```ruby
+# Before
+if user.qualified?
+  user.approve!
+end
+
+# After
+user.approve! if user.qualified?
+```
+
+Works with `unless` too:
+
+```ruby
+# Before
+unless user.banned?
+  user.login!
+end
+
+# After
+user.login! unless user.banned?
+```
+
+#### Convert to block if / Convert to block unless
+
+The reverse operation — expands a trailing modifier back into a full block.
+
+```ruby
+# Before
+user.approve! if user.qualified?
+
+# After
+if user.qualified?
+  user.approve!
+end
+```
+
+#### Convert to unless / Convert to if
+
+Toggles between `if` and `unless` on a block conditional that has no `else`
+branch. When the predicate already starts with `!`, the negation is stripped
+automatically to keep the result clean.
+
+```ruby
+# Before
+if user.active?
+  user.greet!
+end
+
+# After
+unless user.active?
+  user.greet!
+end
+```
+
+```ruby
+# Before — negated predicate
+if !user.banned?
+  user.login!
+end
+
+# After — negation stripped
+unless user.banned?
+  user.login!
+end
+```
+
+#### Invert if/else
+
+Negates the condition and swaps the two branches of an `if/else` block.
+Double-negation (`!!`) is cancelled automatically.
+
+```ruby
+# Before
+if user.admin?
+  grant!
+else
+  deny!
+end
+
+# After
+if !user.admin?
+  deny!
+else
+  grant!
+end
+```
+
+#### Convert to interpolated string
+
+Upgrades a single-quoted string literal to double-quotes so you can immediately
+add `#{}` interpolation. Any `"` characters inside the string are escaped.
+
+```ruby
+# Before
+'hello world'
+
+# After
+"hello world"
+```
+
+---
+
+### Phase 2 — Variable & literal optimisation
+
+#### Inline variable
+
+Removes a local variable assignment and replaces every subsequent read of that
+variable with the original right-hand-side expression.
+
+```ruby
+# Before — cursor on the assignment line
+result = user.calculate
+puts result
+log result
+
+# After
+puts user.calculate
+log user.calculate
+```
+
+#### Extract local variable
+
+Wraps any expression under the cursor in a new local variable assignment
+inserted on the line above.
+
+```ruby
+# Before — cursor on the expression
+user.full_name.upcase
+
+# After
+variable = user.full_name.upcase
+variable
+```
+
+#### Convert to keyword syntax
+
+Converts hash-rocket pairs whose keys are plain symbols into modern keyword
+syntax. Mixed hashes (string keys, computed keys) are handled gracefully —
+only the eligible pairs are converted.
+
+```ruby
+# Before
+{ :name => "Alice", :age => 30 }
+
+# After
+{ name: "Alice", age: 30 }
+```
+
+#### Convert to symbol array
+
+Converts a bracket array of plain symbols into a `%i[]` word array.
+
+```ruby
+# Before
+[:foo, :bar, :baz]
+
+# After
+%i[foo bar baz]
+```
+
+---
+
+### Phase 3 — Advanced structure
+
+#### Extract to method
+
+Extracts a local variable's right-hand-side expression into a new `private`
+method. Variables that are defined before the extraction point and referenced
+inside the expression are automatically detected and forwarded as method
+parameters.
+
+```ruby
+# Before — cursor on the assignment
+def process(data)
+  threshold = 10
+  result = data.select { |x| x > threshold }
+  result
+end
+
+# After
+def process(data)
+  threshold = 10
+  result = result(threshold)
+  result
+end
+
+  private
+
+  def result(threshold)
+    data.select { |x| x > threshold }
+  end
+```
+
+#### Add parameter
+
+Appends a `new_param` placeholder to a method's parameter list. If the method
+has no parameters yet, parentheses are added automatically.
+
+```ruby
+# Before — cursor anywhere inside the def
+def greet(name)
+  puts name
+end
+
+# After
+def greet(name, new_param)
+  puts name
+end
+```
+
+```ruby
+# Before — no parameters
+def greet
+  puts "hello"
+end
+
+# After
+def greet(new_param)
+  puts "hello"
+end
+```
+
+#### Convert to keyword arguments
+
+Rewrites all required positional parameters in a method signature to keyword
+arguments. Optional parameters, rest args, and block parameters are left
+unchanged.
+
+```ruby
+# Before — cursor anywhere inside the def
+def create(name, age)
+  User.new(name, age)
+end
+
+# After
+def create(name:, age:)
+  User.new(name, age)
+end
+```
+
+#### Extract to let _(RSpec)_
+
+When the cursor is on a local variable assignment inside an RSpec `it`,
+`specify`, `example`, or `scenario` block, this action moves the assignment
+into a `let` declaration inserted above the example.
+
+```ruby
+# Before — cursor on the assignment
+it "logs in" do
+  user = User.new(name: "Alice")
+  expect(user.name).to eq("Alice")
+end
+
+# After
+let(:user) { User.new(name: "Alice") }
+
+it "logs in" do
+  expect(user.name).to eq("Alice")
+end
+```
+
+---
+
+## Development
+
+```bash
+bin/setup        # install dependencies
+bundle exec rake test   # run the test suite
+bundle exec rake        # lint + test
+```
+
+To try the add-on against a local project without publishing to RubyGems, add
+a path reference to that project's `Gemfile`:
+
+```ruby
+gem "ruby-lsp-refactor", path: "/path/to/ruby-lsp-refactor"
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/tachyons/ruby-lsp-refactor.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rubocop/rake_task"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs    << "test"
+  t.libs    << "lib"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Lsp
+    module Refactor
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/ruby/lsp/refactor.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "refactor/version"
+
+module Ruby
+  module Lsp
+    module Refactor
+      class Error < StandardError; end
+      # Your code goes here...
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_refactor/addon.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+require "ruby_lsp/requests/code_actions"
+require "ruby_lsp/requests/code_action_resolve"
+require_relative "listeners/conditional_listener"
+require_relative "listeners/variable_listener"
+require_relative "listeners/string_listener"
+require_relative "listeners/hash_listener"
+require_relative "listeners/array_listener"
+require_relative "listeners/method_listener"
+
+module RubyLsp
+  module Refactor
+    # Lightweight value object that satisfies the interface expected by every
+    # listener: #uri and #range.
+    NodeContext = Struct.new(:uri, :range)
+
+    # Prepended into RubyLsp::Requests::CodeActions#perform.
+    #
+    # Runs our own AST walk and appends the resulting actions to whatever
+    # ruby-lsp itself returns.  Each action carries a full `edit:` so no
+    # resolve round-trip is needed (the LSP spec allows this).
+    module CodeActionsExtension
+      def perform
+        actions = super || []
+        actions.concat(RubyLsp::Refactor::Addon.refactor_actions_for(@document, @range))
+        actions
+      end
+    end
+
+    class Addon < ::RubyLsp::Addon
+      # Called once when the language server activates this add-on.
+      def activate(global_state, message_queue)
+        @global_state = global_state
+
+        # Inject our actions into the standard code-actions response.
+        RubyLsp::Requests::CodeActions.prepend(CodeActionsExtension)
+      end
+
+      def deactivate; end
+
+      def name
+        "Ruby LSP Refactor"
+      end
+
+      def version
+        "0.1.0"
+      end
+
+      # Runs the full listener pipeline against +document+ at +range+ and
+      # returns an array of Interface::CodeAction objects.
+      #
+      # Called from CodeActionsExtension#perform and from the test helper.
+      #
+      # @param document [RubyLsp::RubyDocument]
+      # @param range    [Hash]  LSP range hash { start: {line:, character:}, end: {line:, character:} }
+      # @return [Array<Interface::CodeAction>]
+      def self.refactor_actions_for(document, range)
+        return [] unless document.is_a?(RubyLsp::RubyDocument)
+        return [] if document.source.empty?
+
+        cursor_range = Interface::Range.new(
+          start: Interface::Position.new(
+            line:      range.dig(:start, :line),
+            character: range.dig(:start, :character),
+          ),
+          end: Interface::Position.new(
+            line:      range.dig(:end, :line),
+            character: range.dig(:end, :character),
+          ),
+        )
+
+        node_context     = NodeContext.new(document.uri.to_s, cursor_range)
+        response_builder = RubyLsp::ResponseBuilders::CollectionResponseBuilder.new
+        dispatcher       = Prism::Dispatcher.new
+
+        # Phase 1 – Local rewrites
+        ConditionalListener.new(response_builder, node_context, dispatcher)
+        StringListener.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)
+
+        # Phase 3 – Advanced structure
+        MethodListener.new(response_builder, node_context, dispatcher)
+
+        dispatcher.dispatch(document.ast)
+        response_builder.response
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../support/node_helpers"
+
+module RubyLsp
+  module Refactor
+    # Emits a "Convert to symbol array" code action when the cursor is on an
+    # ArrayNode whose every element is a plain SymbolNode.
+    #
+    # Input:   [:foo, :bar, :baz]
+    # Output:  %i[foo bar baz]
+    #
+    # Arrays that already use %i[] or %I[] syntax, or that contain non-symbol
+    # elements, are ignored.
+    class ArrayListener
+      include RubyLsp::Requests::Support::Common
+      include Support::NodeHelpers
+
+      # @param response_builder [RubyLsp::ResponseBuilders::CollectionResponseBuilder]
+      # @param node_context     [RubyLsp::NodeContext]
+      # @param dispatcher       [Prism::Dispatcher]
+      def initialize(response_builder, node_context, dispatcher)
+        @response_builder = response_builder
+        @node_context     = node_context
+
+        dispatcher.register(self, :on_array_node_enter)
+      end
+
+      def on_array_node_enter(node)
+        return unless node_covers_cursor?(node)
+        return unless convertible_to_symbol_array?(node)
+
+        emit_convert_to_symbol_array(node)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Returns true when:
+      #   1. The array uses bracket syntax (not already %i[] / %I[]).
+      #   2. Every element is a plain colon-prefixed SymbolNode.
+      #   3. There is at least one element.
+      def convertible_to_symbol_array?(node)
+        return false if node.elements.empty?
+        return false unless node.opening_loc&.slice == "["
+
+        node.elements.all? do |el|
+          el.is_a?(Prism::SymbolNode) && el.opening_loc&.slice == ":"
+        end
+      end
+
+      def emit_convert_to_symbol_array(node)
+        symbols  = node.elements.map(&:unescaped)
+        new_text = "%i[#{symbols.join(" ")}]"
+
+        @response_builder << Interface::CodeAction.new(
+          title: "Convert to symbol array",
+          kind:  Constant::CodeActionKind::REFACTOR_REWRITE,
+          edit:  single_edit_workspace_edit(node, new_text),
+        )
+      end
+    end
+  end
+end