ruby-lsp-factory_bot-goto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 88f0a2e70a0fa4e7e9beca98174dddd8f526e6aaf672d15e0e3708cc34826cdd
+  data.tar.gz: 8e08b6dfd8c914d6bd1b1e03c085d4a4aeb5d646f3b48b32f0e17cc76fc5b7fd
+SHA512:
+  metadata.gz: 0e4940d123e2e059a089dc4f479faf77eaf80c011c3c7a319c7a940cad94cb4a405081a66805f75c8e42892792e6e256152887b396615d98c7aa0942b579688e
+  data.tar.gz: e1966518e253606a4cefde80b395e0dabab76462fcc79fcf71cb9f7f459922d0d3c3419990830429b7ebc8f1c4ead76321fa73bb2b69095435272a3d2afb29bf

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-01-XX
+
+### Added
+- Initial release
+- Go to Definition support for FactoryBot factories
+- Support for factory aliases (`:aliases` parameter)
+- Recursive indexing of `spec/factories/**/*.rb`
+- Support for all common FactoryBot methods: `create`, `build`, `build_list`, `create_list`, `attributes_for`
+- Support for both symbol and string factory names

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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,138 @@
+# Ruby LSP FactoryBot GoTo
+
+A Ruby LSP addon that provides **"Go to Definition"** support for [FactoryBot](https://github.com/thoughtbot/factory_bot) factories.
+
+> **Note**: This is a separate addon from [`ruby-lsp-factory_bot`](https://rubygems.org/gems/ruby-lsp-factory_bot). That gem provides code completion, while this gem provides navigation (go-to-definition). They complement each other and can be used together!
+
+## Features
+
+- 🎯 **Go to Definition**: Jump from factory references to their definitions
+- 🏷️ **Alias Support**: Works with factory aliases (e.g., `factory :user, aliases: [:admin]`)
+- 📁 **Subdirectories**: Indexes factories in `spec/factories/**/*.rb` recursively
+- ⚡ **Fast**: Uses Prism for efficient AST parsing
+
+### Supported FactoryBot Methods
+
+- `create(:factory_name)`
+- `build(:factory_name)`
+- `build_list(:factory_name)`
+- `create_list(:factory_name)`
+- `attributes_for(:factory_name)`
+
+Works with both symbol and string arguments: `create(:user)` and `create("user")`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :development do
+  gem 'ruby-lsp-factory_bot-goto'
+end
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+The addon will be automatically loaded by Ruby LSP.
+
+## Usage
+
+Once installed, the addon automatically activates when you use Ruby LSP. Simply:
+
+1. Place your cursor on a factory name in a FactoryBot call (e.g., `:user` in `create(:user)`)
+2. Use "Go to Definition" (typically `F12` or `Cmd+Click` in VS Code)
+3. Jump directly to the factory definition!
+
+## Example
+
+Given a factory definition:
+
+```ruby
+# spec/factories/users.rb
+FactoryBot.define do
+  factory :user do
+    name { "John Doe" }
+    email { "john@example.com" }
+  end
+end
+```
+
+You can now jump to it from any test:
+
+```ruby
+# spec/models/user_spec.rb
+it "creates a user" do
+  user = create(:user)  # <- Cmd+Click on :user jumps to the factory!
+end
+```
+
+### Factory Aliases
+
+The addon fully supports factory aliases:
+
+```ruby
+# spec/factories/users.rb
+FactoryBot.define do
+  factory :user, aliases: [:admin, :member] do
+    name { "John Doe" }
+  end
+end
+```
+
+Now all three names work: `create(:user)`, `create(:admin)`, `create(:member)`
+
+## How It Works
+
+The addon:
+
+1. Indexes all factories in `spec/factories/**/*.rb` when Ruby LSP starts
+2. Parses factory definitions using Prism to extract names and aliases
+3. Listens for FactoryBot method calls in your code
+4. Provides location information for "Go to Definition" requests
+
+## Requirements
+
+- Ruby >= 3.0
+- Ruby LSP >= 0.26
+- Prism >= 0.19
+
+## Development
+
+To test the addon locally in your Rails project:
+
+1. Add it to your project's Gemfile with a `path:` directive:
+   ```ruby
+   gem 'ruby-lsp-factory_bot-goto', path: '~/projects/ruby-lsp-factory_bot-goto'
+   ```
+2. Run `bundle install`
+3. Restart your Ruby LSP server
+
+## Building and Publishing
+
+To build the gem:
+
+```bash
+gem build ruby-lsp-factory_bot-goto.gemspec
+```
+
+To publish to RubyGems:
+
+```bash
+gem push ruby-lsp-factory_bot-goto-0.1.0.gem
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tylercainerhodes/ruby-lsp-factory_bot-goto.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Credits
+
+Built with [Ruby LSP](https://shopify.github.io/ruby-lsp/) and [Prism](https://ruby.github.io/prism/).

data/lib/ruby_lsp/factory_bot/addon.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'ruby-lsp'
+require 'ruby_lsp/addon'
+require_relative 'factory_index'
+require_relative 'definition_listener'
+
+module RubyLsp
+  module FactoryBot
+    # Ruby LSP addon that provides "Go to Definition" for FactoryBot factory references.
+    # Indexes all factories in spec/factories/**/*.rb and enables jumping to factory definitions
+    # from calls like create(:factory_name), build(:factory_name), etc.
+    class Addon < ::RubyLsp::Addon
+      def initialize
+        super
+        @factory_index = FactoryIndex.new
+      end
+
+      def activate(global_state, _outgoing_queue)
+        workspace_root = global_state&.workspace_path || Dir.pwd
+        @factory_index.rebuild!(workspace_root)
+      end
+
+      def name
+        'Ruby LSP FactoryBot'
+      end
+
+      def version
+        '0.1.0'
+      end
+
+      def create_definition_listener(response_builder, _uri, node_context, dispatcher)
+        DefinitionListener.new(response_builder, node_context, @factory_index, dispatcher)
+      end
+
+      def deactivate; end
+    end
+  end
+end

data/lib/ruby_lsp/factory_bot/definition_listener.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'ruby_lsp/requests/support/common'
+require 'language_server/protocol/interface'
+
+module RubyLsp
+  module FactoryBot
+    class DefinitionListener
+      include ::RubyLsp::Requests::Support::Common
+
+      FACTORY_METHODS = %i[create build build_list create_list attributes_for].freeze
+
+      def initialize(response_builder, node_context, factory_index, dispatcher)
+        @response_builder = response_builder
+        @node_context = node_context
+        @factory_index = factory_index
+
+        dispatcher.register(self, :on_symbol_node_enter, :on_string_node_enter)
+      end
+
+      def on_symbol_node_enter(node)
+        handle_factory_reference(node.value)
+      end
+
+      def on_string_node_enter(node)
+        handle_factory_reference(node.content)
+      end
+
+      private
+
+      def handle_factory_reference(factory_name)
+        call = @node_context.call_node
+        return unless call && FACTORY_METHODS.include?(call.name)
+
+        entry = @factory_index.lookup(factory_name)
+        return unless entry
+
+        @response_builder << location_from_entry(entry)
+      end
+
+      def location_from_entry(entry)
+        LanguageServer::Protocol::Interface::Location.new(
+          uri:   entry.uri,
+          range: range_from_location(entry.location)
+        )
+      end
+
+      def range_from_location(location)
+        LanguageServer::Protocol::Interface::Range.new(
+          start: position_from_line_column(location.start_line, location.start_column),
+          end:   position_from_line_column(location.end_line, location.end_column)
+        )
+      end
+
+      def position_from_line_column(line, column)
+        LanguageServer::Protocol::Interface::Position.new(
+          line:      line - 1,
+          character: column
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/factory_bot/factory_index.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'prism'
+
+module RubyLsp
+  module FactoryBot
+    class FactoryIndex
+      Entry = Struct.new(:uri, :location)
+
+      def initialize
+        @mutex = Mutex.new
+        @entries = {}
+      end
+
+      def rebuild!(workspace_root)
+        new_entries = {}
+        factory_pattern = File.join(workspace_root, 'spec', 'factories', '**', '*.rb')
+
+        Dir.glob(factory_pattern).each do |path|
+          parse_factory_file(path, new_entries)
+        end
+
+        @mutex.synchronize { @entries = new_entries }
+      end
+
+      def lookup(name)
+        @mutex.synchronize { @entries[name.to_s] }
+      end
+
+      private
+
+      def parse_factory_file(path, entries)
+        source = File.read(path)
+        ast = Prism.parse(source)
+        uri = URI("file://#{path}").to_s
+
+        index_factories(ast.value, uri, entries)
+      end
+
+      def index_factories(node, uri, entries)
+        return unless node.respond_to?(:child_nodes)
+
+        node.child_nodes.each do |child|
+          next unless child
+
+          if factory_definition?(child)
+            extract_factory_names(child).each do |name, location|
+              entries[name] = Entry.new(uri, location)
+            end
+          end
+
+          index_factories(child, uri, entries)
+        end
+      end
+
+      def factory_definition?(node)
+        node.is_a?(Prism::CallNode) &&
+          node.name == :factory &&
+          node.arguments&.arguments&.first.is_a?(Prism::SymbolNode)
+      end
+
+      def extract_factory_names(node)
+        args = node.arguments.arguments
+        primary_name = args.first
+        location = primary_name.location
+
+        names = [[primary_name.value.to_s, location]]
+
+        # Add aliases if present
+        extract_aliases(args).each do |alias_name|
+          names << [alias_name, location]
+        end
+
+        names
+      end
+
+      def extract_aliases(args)
+        keyword_hash = args.find { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        return [] unless keyword_hash
+
+        aliases_assoc =
+          keyword_hash.elements.find do |el|
+            el.is_a?(Prism::AssocNode) &&
+              el.key.is_a?(Prism::SymbolNode) &&
+              el.key.value.to_s == 'aliases'
+          end
+
+        return [] unless aliases_assoc
+
+        array_value = aliases_assoc.value
+        return [] unless array_value.is_a?(Prism::ArrayNode)
+
+        array_value.elements.filter_map do |element|
+          case element
+          when Prism::SymbolNode then element.value.to_s
+          when Prism::StringNode then element.content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/factory_bot.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'factory_bot/addon'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: ruby-lsp-factory_bot-goto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tyler Rhodes
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+description: Provides 'Go to Definition' functionality for FactoryBot factories in
+  Ruby LSP. Jump from factory references like create(:user) directly to factory definitions.
+email:
+- tyler.rhodes@aya.yale.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/ruby_lsp/factory_bot.rb
+- lib/ruby_lsp/factory_bot/addon.rb
+- lib/ruby_lsp/factory_bot/definition_listener.rb
+- lib/ruby_lsp/factory_bot/factory_index.rb
+homepage: https://github.com/tylercainerhodes/ruby-lsp-factory_bot-goto
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tylercainerhodes/ruby-lsp-factory_bot-goto
+  source_code_uri: https://github.com/tylercainerhodes/ruby-lsp-factory_bot-goto
+  changelog_uri: https://github.com/tylercainerhodes/ruby-lsp-factory_bot-goto/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: Ruby LSP addon for FactoryBot go-to-definition support
+test_files: []