ruby-lsp-rails-factory-bot 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41ed188af5e2b4b289442274d6538f7105ce3d0e93dd7340923b7f752c7b042b
-  data.tar.gz: a8b258fb2f0c05d17f614d3614515da65b29c04c95c17d7a39c2cd13bc1df261
+  metadata.gz: 01d1b4f936612100587a05ace6ca2c46fd654484c7d1125245e3c3afd7ce2fb2
+  data.tar.gz: cd15946860a27dbaa31ba14b8f429c5afb7f4bd21a9eeb1aca0f01411006bebf
 SHA512:
-  metadata.gz: dbcb7349c449d4d33076e65c04060ca179c150a204d9d6ce93b274bdd5f25357c98a32263a98092943f7845086d8117266394af00f086db21750bf4d83963f92
-  data.tar.gz: a2053e5de42267b86d927e7e0aa3fd4ab99475d9d82843086d4d91b1bb08dfa3efccf1a28aa79fbfd17990ee8d5bb330f99418590a561e878003b728f8ba39be
+  metadata.gz: e09bd8301b1003c30ba6efdba15c6c945f4f0ca0adbda81e8f290bcf4a0dff480c1c482e28499a5477d80a656a358018788a6a5022441da8698c940272089e2c
+  data.tar.gz: 3b145ca533d21b291cd545dde273f4c6f333ea255beca536c01f44e488b02a813d4beab114a4d4269b3c0add785b020df3cc875777d28183b2f338a7005a38df

data/.rubocop.yml

@@ -1,8 +1,28 @@
 AllCops:
   TargetRubyVersion: 3.0
+  NewCops: enable
+  Exclude:
+    - '**/*.gemspec'
+    - '**/vendor/bundle/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*_spec.rb'
+
+Style/RedundantReturn:
+  AllowMultipleReturnValues: true
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma

data/README.md

@@ -20,6 +20,24 @@ Hover over an attribute or factory definition
 
 ![lsp-factory-bot-hover](https://github.com/user-attachments/assets/6f570288-3cf3-4d12-acf9-71c86e834cd8)
 
+Receive completion suggestions as you type
+
+![lsp-factory-bot-completion](https://github.com/user-attachments/assets/4255a86a-8f36-4de2-8d10-8cb5a3f49e50)
+
+### Supports
+
+|         | Hover           | Completion  | Go to definition |
+| ------------- |-------------| -----| ----|
+| Factory name      | ✅ | ⭕️ | ❌ |
+| Trait      | ✅      |  ⭕️ | ❌ |
+| Attribute | ✅      |  ✅ | ❌ |
+
+Notes:
+
+- The extension has "understanding" of factory/trait completion items, but due to limitations on when ruby-lsp displays the completion suggestions, they aren't visible for Symbols (eg. factory/trait names) :/ though they happen to be visible for symbols in Hash/Kw notation (ie with `:` after - `key: ...`)
+- Go to definition not supported yet but might come soon
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -2,7 +2,9 @@
 
 require "bundler/gem_tasks"
 require "rubocop/rake_task"
+require "rspec/core/rake_task"
 
 RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :rubocop
+task default: %i[rubocop spec]

data/lib/ruby_lsp/rails/factory_bot/addon.rb

@@ -1,37 +1,45 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/addon"
-require "ruby_lsp_rails/runner_client"
+require "ruby_lsp/ruby_lsp_rails/addon"
 
 require_relative "completion"
 require_relative "hover"
-require_relative "server_extension"
+require_relative "addon_name"
+require_relative "../factory_bot"
+require_relative "../../../ruby_lsp_rails_factory_bot"
 
 module RubyLsp
   module Rails
     module FactoryBot
+      # The addon to be registered with ruby-lsp. See https://shopify.github.io/ruby-lsp/add-ons.html
       class Addon < ::RubyLsp::Addon
-        def activate(global_state, *)
+        def activate(global_state, outgoing_queue)
           @ruby_index = global_state.index
+
+          @outgoing_queue = outgoing_queue
+          log "Activating #{name} add-on v#{VERSION}"
         end
 
         def deactivate(*); end
 
         def name
-          "ruby-lsp-rails-factory-bot"
+          FactoryBot::ADDON_NAME
         end
 
-        def create_completion_listener(response_builder, node_context, dispatcher, uri)
-          path = uri.to_standardized_path
-          return unless path&.end_with?("_test.rb") || path&.end_with?("_spec.rb")
-          return unless factory_bot_call_args?(node_context)
-
-          Completion.new(response_builder, node_context, dispatcher, RubyLsp::Rails::RunnerClient.instance)
+        def create_completion_listener(response_builder, node_context, dispatcher, _uri)
+          register_addon!
+          Completion.new(response_builder, node_context, dispatcher, runner_client)
         end
 
+        # TODO: need URI param to be able to filter by file name
         def create_hover_listener(response_builder, node_context, dispatcher)
-          # TODO: need URI param
-          Hover.new(response_builder, node_context, dispatcher, RubyLsp::Rails::RunnerClient.instance, @ruby_index)
+          unless @addon_registered
+            register_addon!
+            return
+          end
+
+          Hover.new(response_builder, node_context, dispatcher, runner_client, @ruby_index)
         end
 
         def workspace_did_change_watched_files(changes)
@@ -39,21 +47,33 @@ module RubyLsp
             change[:uri].match?(/(?:spec|test).+factor.+\.rb/)
           end
 
-          RubyLsp::Rails::RunnerClient.instance.trigger_reload
+          runner_client.trigger_reload
         end
 
         private
 
-        FACTORY_BOT_METHODS = %i[
-          create
-          build
-          build_stubbed
-          attributes_for
-        ].flat_map { |attr| [attr, :"#{attr}_list", :"#{attr}_pair"] }.freeze
+        # the addon must be registered as a rails server addon once the server has booted
+        def register_addon!
+          @addon_registered ||= # rubocop:disable Naming/MemoizedInstanceVariableName
+            begin
+              addon_path = File.expand_path("server_addon.rb", __dir__)
+              runner_client.register_server_addon(addon_path)
+              true
+            end
+        end
+
+        def runner_client
+          @rails_addon ||= ::RubyLsp::Addon.get(
+            "Ruby LSP Rails",
+            ::RubyLsp::Rails::FactoryBot::REQUIRED_RUBY_LSP_RAILS_VERSION,
+          )
+          @rails_addon.rails_runner_client
+        end
+
+        def log(msg)
+          return if !@outgoing_queue || @outgoing_queue.closed?
 
-        def factory_bot_call_args?(node_context)
-          node_context.call_node && FACTORY_BOT_METHODS.include?(node_context.call_node.name)
-          true
+          @outgoing_queue << Notification.window_log_message(msg)
         end
       end
     end

data/lib/ruby_lsp/rails/factory_bot/addon_name.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      ADDON_NAME = "ruby-lsp-rails-factory-bot"
+    end
+  end
+end

data/lib/ruby_lsp/rails/factory_bot/completion.rb

@@ -2,20 +2,15 @@
 
 require "ruby_lsp/internal"
 
+require_relative "addon_name"
+
 module RubyLsp
   module Rails
     module FactoryBot
-      class Completion
+      # The listener that is created when the user requests autocomplete at the relevant time.
+      class Completion # rubocop:disable Metrics/ClassLength
         include RubyLsp::Requests::Support::Common
 
-        # TODO: Avoid duplication with other class
-        FACTORY_BOT_METHODS = %i[
-          create
-          build
-          build_stubbed
-          attributes_for
-        ].flat_map { |attr| [attr, :"#{attr}_list", :"#{attr}_pair"] }.freeze
-
         def initialize(response_builder, node_context, dispatcher, server_client)
           @response_builder = response_builder
           @node_context = node_context
@@ -25,103 +20,146 @@ module RubyLsp
         end
 
         def on_call_node_enter(node)
-          return unless FACTORY_BOT_METHODS.include?(node.name) ||
-                        FACTORY_BOT_METHODS.include?(@node_context.parent.name)
+          call_node = @node_context.call_node
+          return unless call_node
+
+          return unless FactoryBot::FACTORY_BOT_METHODS.include?(call_node.name)
+
+          process_arguments_pattern(node, call_node.arguments&.arguments)
+        rescue StandardError => e
+          $stderr.write(e, e.backtrace)
+        end
 
-          case node.arguments
+        private
+
+        def process_arguments_pattern(node, arguments) # rubocop:disable Metrics/MethodLength
+          case arguments
           in [Prism::SymbolNode => factory_name_node]
-            handle_factory(factory_name_node, factory_name_node.value.to_s)
+            handle_factory(factory_name_node, node_string_value(factory_name_node))
 
           in [Prism::SymbolNode => factory_name_node, *, Prism::SymbolNode => trait_node]
-            handle_trait(factory_name_node.value.to_s, node, trait_node.value.to_s)
+            already_used_traits = gather_already_used_traits(arguments)
+            handle_trait(
+              node_string_value(factory_name_node), node, already_used_traits, node_string_value(trait_node),
+            )
 
-          in [Prism::SymbolNode => factory_name_node, *, Prism::CallNode => call_node]
-            handle_attribute(factory_name_node.value.to_s, node, call_node.message)
+          in [Prism::SymbolNode => _factory_name_node, *, Prism::KeywordHashNode => _kw_node] |
+            [Prism::SymbolNode => _factory_name_node, *, Prism::HashNode => _kw_node] |
+            [Prism::SymbolNode => _factory_name_node, *, Prism::CallNode => _call_node]
 
-          in [Prism::SymbolNode => factory_name_node, *, Prism::KeywordHashNode => kw_node]
-            handle_attribute(
-              factory_name_node.value.to_s, node, kw_node.elements.last.key.value&.to_s
-            )
-          in [Prism::SymbolNode => factory_name_node, *, Prism::HashNode => hash_node]
-            handle_attribute(
-              factory_name_node.value.to_s, node, hash_node.elements.last.key.value&.to_s
-            )
+            attr_name = node_string_value(_call_node || _kw_node.elements.last.key)
+            already_used_attrs = gather_already_used_attrs(_kw_node)
+            handle_attribute(node_string_value(_factory_name_node), node, already_used_attrs, attr_name)
           else
-            $stderr.write node.arguments
             nil
           end
-        rescue => e
-          $stderr.write(e, e.backtrace)
         end
 
-        private
+        def node_string_value(node)
+          case node
+          when Prism::CallNode
+            node.name.to_s
+          when Prism::SymbolNode
+            node.value.to_s
+          when nil
+            ""
+          end
+        end
 
-        def handle_attribute(factory_name, node, value = "")
-          @server_client.get_attributes(factory_name: factory_name, name: value)&.each do |attr|
-            $stderr.write "attribute", attr
-            label_details = Interface::CompletionItemLabelDetails.new(
-              description: attr[:type],
-            )
-            range = range_from_node(node)
+        def gather_already_used_attrs(kw_node)
+          attrs = Set.new
+          return attrs unless kw_node
 
-            @response_builder << Interface::CompletionItem.new(
-              label: attr[:name],
-              filter_text: attr[:name],
-              label_details: label_details,
-              text_edit: Interface::TextEdit.new(range: range, new_text: attr[:name]),
-              kind: Constant::CompletionItemKind::PROPERTY,
-              data: {
-                owner_name: attr[:owner],
-                guessed_type: attr[:owner], # the type of the owner, not the attribute
-              },
-            )
+          kw_node.elements.each do |e|
+            attrs.add(node_string_value(e.key))
           end
+
+          attrs
         end
 
-        def handle_trait(factory_name, node, value = "")
-          @server_client.get_traits(factory_name: factory_name, name: value)&.each do |tr|
-            $stderr.write "trait", tr
-            label_details = Interface::CompletionItemLabelDetails.new(
-              description: tr[:owner],
-            )
-            range = range_from_node(node)
+        def handle_attribute(factory_name, node, already_used_attrs, value = "")
+          range = range_from_node(node)
+          make_request(:attributes, factory_name: factory_name, name: value)&.each do |attr|
+            next if already_used_attrs.member?(attr[:name].to_s)
 
+            label_details = Interface::CompletionItemLabelDetails.new(description: attr[:type])
+
+            @response_builder << serialise_attribute(attr[:name], label_details, attr[:owner], range)
+          end
+        end
+
+        def serialise_attribute(name, label_details, owner, range)
+          Interface::CompletionItem.new(
+            label: name,
+            filter_text: name,
+            label_details: label_details,
+            text_edit: Interface::TextEdit.new(range: range, new_text: name),
+            kind: Constant::CompletionItemKind::PROPERTY,
+            data: { owner_name: owner, guessed_type: owner }, # the type of the owner, not the attribute
+          )
+        end
+
+        def gather_already_used_traits(arguments)
+          trait_names = Set.new
+          # skip the first one because it's factory name
+          1.upto(arguments.length - 1) do |i|
+            arg = arguments[i]
+            next if arg.is_a?(Prism::IntegerNode)
+            break unless arg.is_a?(Prism::SymbolNode)
+
+            trait_names.add(arg.value.to_s)
+          end
+          trait_names
+        end
+
+        def handle_trait(factory_name, node, already_used_traits, value = "")
+          make_request(:traits, factory_name: factory_name, name: value)&.each do |tr|
+            next if already_used_traits.member?(tr[:name].to_s)
+
+            label_details = Interface::CompletionItemLabelDetails.new(description: tr[:owner])
+            range = range_from_node(node)
             name = tr[:name]
 
-            @response_builder << Interface::CompletionItem.new(
-              label: name,
-              filter_text: name,
-              label_details: label_details,
-              text_edit: Interface::TextEdit.new(range: range, new_text: name),
-              kind: Constant::CompletionItemKind::PROPERTY,
-              data: {
-                owner_name: nil,
-                guessed_type: tr[:owner] # the type of the owner
-              },
-            )
+            @response_builder << serialise_trait(name, range, label_details, tr[:owner])
           end
         end
 
+        def serialise_trait(name, range, label_details, owner)
+          Interface::CompletionItem.new(
+            label: name,
+            filter_text: name,
+            label_details: label_details,
+            text_edit: Interface::TextEdit.new(range: range, new_text: name),
+            kind: Constant::CompletionItemKind::PROPERTY,
+            data: { owner_name: nil, guessed_type: owner },
+          )
+        end
+
         def handle_factory(node, name)
-          @server_client.get_factories(name: name)&.each do |fact|
-            $stderr.write "factory", fact
-            @response_builder << Interface::CompletionItem.new(
-              label: fact[:name],
-              filter_text: fact[:name],
-              label_details: Interface::CompletionItemLabelDetails.new(
-                description: fact[:model_class]
-              ),
-              text_edit: Interface::TextEdit.new(
-                range: range_from_node(node),
-                new_text: fact[:name],
-              ),
-              kind: Constant::CompletionItemKind::CLASS,
-              data: {
-                guessed_type: fact[:model_class]
-              }
-            )
+          range = range_from_node(node)
+          make_request(:factories, name: name)&.each do |fact|
+            @response_builder << serialise_factory(fact[:name], fact[:model_class], range)
           end
         end
+
+        def make_request(request_name, **params)
+          @server_client.delegate_request(
+            server_addon_name: FactoryBot::ADDON_NAME,
+            request_name: request_name.to_s,
+            **params,
+          )
+        end
+
+        def serialise_factory(name, model_class, range)
+          Interface::CompletionItem.new(
+            label: name,
+            filter_text: name,
+            label_details: Interface::CompletionItemLabelDetails.new(description: model_class),
+            text_edit: Interface::TextEdit.new(range: range, new_text: name),
+            kind: Constant::CompletionItemKind::CLASS,
+            data: { guessed_type: model_class },
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/rails/factory_bot/hover.rb

@@ -2,20 +2,15 @@
 
 require "ruby_lsp/internal"
 
+require_relative "addon_name"
+
 module RubyLsp
   module Rails
     module FactoryBot
+      # The listener that is created during relevant hover actions
       class Hover
         include RubyLsp::Requests::Support::Common
 
-        # TODO: Avoid duplication with other class
-        FACTORY_BOT_METHODS = %i[
-          create
-          build
-          build_stubbed
-          attributes_for
-        ].flat_map { |attr| [attr, :"#{attr}_list", :"#{attr}_pair"] }.freeze
-
         def initialize(response_builder, node_context, dispatcher, server_client, ruby_index)
           @response_builder = response_builder
           @node_context = node_context
@@ -34,83 +29,86 @@ module RubyLsp
           # "parent" isn't strictly speaking the immediate parent as in the AST - the
           # element it refers to is a bit opinionated... in this case, it is always the call node,
           # whether the symbol is an argument in the call_node args, or a symbol in a kw hash :/
-          unless parent.is_a?(Prism::CallNode) || FACTORY_BOT_METHODS.include?(call_node.message.to_sym)
+          unless parent.is_a?(Prism::CallNode) || FactoryBot::FACTORY_BOT_METHODS.include?(call_node.message.to_sym)
             return
           end
 
-          case call_node.arguments.arguments
+          process_arguments_pattern(symbol_node, call_node.arguments.arguments)
+        end
+
+        private
+
+        def process_arguments_pattern(symbol_node, arguments) # rubocop:disable Metrics/MethodLength
+          case arguments
           in [^symbol_node, *]
             handle_factory(symbol_node)
-          in [Prism::SymbolNode => factory_node, *, ^symbol_node]
-            handle_trait(symbol_node, factory_node)
-          in [Prism::SymbolNode => factory_node, ^symbol_node, *]
-            handle_trait(symbol_node, factory_node)
-          in [Prism::SymbolNode => factory_node, Integer, ^symbol_node, *]
-            handle_trait(symbol_node, factory_node)
-          in [Prism::SymbolNode => factory_node, *, Prism::KeywordHashNode => kw_hash] if kw_hash.elements.any? { |e| e.key == symbol_node }
-            handle_attribute(symbol_node, factory_node)
-          in [Prism::SymbolNode => factory_node, *, Prism::HashNode => kw_hash] if kw_hash.elements.any? { |e| e.key == symbol_node }
-            handle_attribute(symbol_node, factory_node)
+          in [Prism::SymbolNode => _factory_node, *, ^symbol_node] |
+             [Prism::SymbolNode => _factory_node, ^symbol_node, *] |
+             [Prism::SymbolNode => _factory_node, Integer, ^symbol_node, *]
+
+            handle_trait(symbol_node, _factory_node)
+
+          in [Prism::SymbolNode => _factory_node, *, Prism::KeywordHashNode => _kw_hash] |
+             [Prism::SymbolNode => _factory_node, *, Prism::HashNode => _kw_hash]
+
+            handle_attribute(symbol_node, _factory_node) if _kw_hash.elements.any? { |e| e.key == symbol_node }
           else
-            $stderr.write "nope fact_or_trait", call_node.arguments.arguments
             nil
           end
         end
 
-        private
-
         def handle_attribute(symbol_node, factory_node)
           name = symbol_node.value.to_s
-          attribute = @server_client.get_attributes(
-            factory_name: factory_node.value.to_s, name: name
+          attribute = make_request(
+            :attributes,
+            factory_name: factory_node.value.to_s, name: name,
           )&.find { |attr| attr[:name] == name }
 
           return unless attribute
 
           @response_builder.push(
             "#{attribute[:name]} (#{attribute[:type]})",
-            category: :documentation
+            category: :documentation,
           )
         end
 
         def handle_factory(symbol_node)
           name = symbol_node.value.to_s
-
-          factory = @server_client.get_factories(name: name)&.find { |f| f[:name] == name }
-
+          factory = make_request(:factories, name: name)&.find { |f| f[:name] == name }
           return unless factory
 
           index_entry = @ruby_index.first_unqualified_const(factory[:name])
 
-          if index_entry
-            @response_builder.push(
-              markdown_from_index_entries(
-                factory[:model_class],
-                index_entry
-              ),
-              category: :documentation
-            )
-          else
-            @response_builder.push(
-              "#{factory[:name]} (#{factory[:model_class]})",
-              category: :documentation
-            )
-          end
+          hint = if index_entry
+                   markdown_from_index_entries(factory[:model_class], index_entry)
+                 else
+                   "#{factory[:name]} (#{factory[:model_class]})"
+                 end
+
+          @response_builder.push(hint, category: :documentation)
         end
 
         def handle_trait(symbol_node, factory_node)
           factory_name = factory_node.value.to_s
           trait_name = symbol_node.value.to_s
 
-          trait = @server_client.get_traits(
-            factory_name: factory_name, name: trait_name
-          )&.find { |tr| tr[:name] == trait_name }
+          trait = make_request(:traits, factory_name: factory_name, name: trait_name)&.find do |tr|
+            tr[:name] == trait_name
+          end
 
           return unless trait
 
           @response_builder.push(
             "#{trait[:name]} (trait of #{trait[:owner] || factory_name})",
-            category: :documentation
+            category: :documentation,
+          )
+        end
+
+        def make_request(request_name, **params)
+          @server_client.delegate_request(
+            server_addon_name: FactoryBot::ADDON_NAME,
+            request_name: request_name.to_s,
+            **params,
           )
         end
       end

data/lib/ruby_lsp/rails/factory_bot/server_addon/attribute_handler.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "base_handler"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      class ServerAddon < RubyLsp::Rails::ServerAddon
+        # Handler for fetching and serialising traits
+        class AttributeHandler < BaseHandler
+          private
+
+          def fetch(params)
+            factory = ::FactoryBot.factories[params[:factory_name]]
+            name = params[:name]
+
+            attributes = factory.definition.declarations.select do |attr|
+              name.nil? || name.empty? ? true : attr.name.to_s.include?(name)
+            end
+            model_class = factory.send :class_name
+
+            return attributes, model_class
+          rescue KeyError
+            # FactoryBot throws a KeyError if the factory isn't found, so nothing to do here
+          end
+
+          def serialise(attributes, model_class)
+            attributes.map do |attribute|
+              source_location = block_for(attribute)&.source_location
+              {
+                name: attribute.name,
+                owner: model_class.name,
+                type: guess_attribute_type(attribute, model_class),
+                source_location: source_location,
+                source: block_source(attribute),
+              }
+            end
+          end
+
+          def guess_attribute_type(attribute, model_class)
+            if model_class.respond_to? :attribute_types
+              type = model_class.attribute_types[attribute.name.to_s]
+              return nil if type.nil?
+
+              return ACTIVE_MODEL_TYPE_TO_RUBY_TYPE[type.class] || type.type
+            end
+
+            return unless model_class.respond_to? :reflections
+
+            association = model_class.reflections[attribute.name.to_s]
+
+            association&.klass
+          end
+
+          ACTIVE_MODEL_TYPE_TO_RUBY_TYPE = {
+            ActiveModel::Type::String => "String",
+            ActiveModel::Type::ImmutableString => "String",
+            ActiveModel::Type::Float => "Float",
+            ActiveModel::Type::Integer => "Integer",
+            ActiveModel::Type::Boolean => "boolean",
+            ActiveModel::Type::Date => "Date",
+            ActiveModel::Type::Time => "Time",
+            ActiveModel::Type::DateTime => "DateTime",
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/rails/factory_bot/server_addon/base_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      class ServerAddon < RubyLsp::Rails::ServerAddon
+        # Common handler functionality
+        class BaseHandler
+          def execute(params)
+            collection, *rest = fetch(params)
+
+            serialise(collection, *rest) if collection
+          end
+
+          private
+
+          def fetch(_params) = throw("Not implemented")
+
+          def serialise(_collection, *) = throw("Not implemented")
+
+          # helper - might be best to live elsewhere?
+          def block_for(attr)
+            attr.instance_variable_get :@block
+          end
+
+          # helper - might be best to live elsewhere?
+          def block_source(attr)
+            blk = block_for(attr)
+            blk.source if blk.respond_to? :source
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/rails/factory_bot/server_addon/factory_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base_handler"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      class ServerAddon < RubyLsp::Rails::ServerAddon
+        # Handler for fetching and serialising factories
+        class FactoryHandler < BaseHandler
+          private
+
+          def fetch(params)
+            name = params[:name]
+            factories = ::FactoryBot.factories.select do |f|
+              name.nil? || name.empty? ? true : f.name.to_s.include?(params[:name])
+            end
+            return factories, nil
+          end
+
+          def serialise(factories, *)
+            factories.map do |fact|
+              model_class = fact.send :class_name
+
+              case model_class
+              when String, Symbol
+                model_class = model_class.to_s.camelize
+              end
+
+              { name: fact.name, model_class: model_class }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/rails/factory_bot/server_addon/trait_handler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base_handler"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      class ServerAddon < RubyLsp::Rails::ServerAddon
+        # Handler for fetching and serialising traits
+        class TraitHandler < BaseHandler
+          private
+
+          def fetch(params)
+            factory = ::FactoryBot.factories[params[:factory_name]]
+
+            trait_name_partial = params[:name]
+            defined_traits = defined_traits(factory, trait_name_partial)
+            internal_traits = internal_traits(factory.send(:class_name), trait_name_partial)
+
+            traits = defined_traits.concat(internal_traits)
+            return traits, nil
+          rescue KeyError
+            # FactoryBot throws a KeyError if the factory isn't found, so nothing to do here
+          end
+
+          def defined_traits(factory, trait_name_partial)
+            factory.defined_traits.select { |tr| tr.name.to_s.include? trait_name_partial }
+          end
+
+          def internal_traits(factory_class_name, trait_name_partial)
+            ::FactoryBot::Internal.traits.select do |tr|
+              (tr.klass == factory_class_name || !tr.klass) && tr.name.to_s.include?(trait_name_partial)
+            end
+          end
+
+          def serialise(traits, *)
+            traits.map do |tr|
+              source_location = block_for(tr)&.source_location
+              {
+                name: tr.name,
+                source_location: source_location,
+                source: block_source(tr),
+                owner: tr.klass,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/rails/factory_bot/server_addon.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "addon_name"
+require_relative "server_addon/factory_handler"
+require_relative "server_addon/trait_handler"
+require_relative "server_addon/attribute_handler"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      # The addon for the ruby-lsp-rails server runtime
+      class ServerAddon < RubyLsp::Rails::ServerAddon
+        def initialize(stdout, stderr, capabilities)
+          super
+
+          # TODO: move to before_start hook
+          with_progress "ruby-lsp-rails-factory-bot-1", "initialisation" do
+            require "factory_bot"
+            ::FactoryBot.find_definitions
+            ::FactoryBot.factories.each(&:compile)
+          end
+        end
+
+        def name = FactoryBot::ADDON_NAME
+
+        def execute(request, params) # rubocop:disable Metrics/MethodLength
+          case request.to_sym
+          when :factories
+            collection = FactoryHandler.new.execute(params)
+          when :traits
+            collection = TraitHandler.new.execute(params)
+          when :attributes
+            collection = AttributeHandler.new.execute(params)
+          else
+            return send_error_response("#{request} no supported")
+          end
+
+          send_result(collection || [])
+        rescue => e # rubocop:disable Style/RescueStandardError
+          send_error_response("An error occurred while fetching #{request} - #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/rails/factory_bot.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      FACTORY_BOT_METHODS = %i[
+        create
+        build
+        build_stubbed
+        attributes_for
+      ].flat_map { |attr| [attr, :"#{attr}_list", :"#{attr}_pair"] }.freeze
+    end
+  end
+end

data/lib/ruby_lsp_rails_factory_bot.rb

@@ -3,7 +3,8 @@
 module RubyLsp
   module Rails
     module FactoryBot
-      VERSION = "0.1.0".freeze
+      VERSION = "0.3.0"
+      REQUIRED_RUBY_LSP_RAILS_VERSION = "~> 0.4"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails-factory-bot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - johansenja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-11 00:00:00.000000000 Z
+date: 2025-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot
@@ -30,22 +30,36 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.17
+        version: '0.23'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.17
+        version: '0.23'
 - !ruby/object:Gem::Dependency
   name: ruby-lsp-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -64,18 +78,24 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/ruby_lsp/rails/factory_bot.rb
 - lib/ruby_lsp/rails/factory_bot/addon.rb
+- lib/ruby_lsp/rails/factory_bot/addon_name.rb
 - lib/ruby_lsp/rails/factory_bot/completion.rb
 - lib/ruby_lsp/rails/factory_bot/hover.rb
-- lib/ruby_lsp/rails/factory_bot/server_extension.rb
+- lib/ruby_lsp/rails/factory_bot/server_addon.rb
+- lib/ruby_lsp/rails/factory_bot/server_addon/attribute_handler.rb
+- lib/ruby_lsp/rails/factory_bot/server_addon/base_handler.rb
+- lib/ruby_lsp/rails/factory_bot/server_addon/factory_handler.rb
+- lib/ruby_lsp/rails/factory_bot/server_addon/trait_handler.rb
 - lib/ruby_lsp_rails_factory_bot.rb
 - sig/ruby_lsp/rails/factory_bot.rbs
-homepage: https://github.com/johansenja/ruby-lsp-factory-bot
+homepage: https://github.com/johansenja/ruby-lsp-rails-factory-bot
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/johansenja/ruby-lsp-factory-bot
+  homepage_uri: https://github.com/johansenja/ruby-lsp-rails-factory-bot
   source_code_uri: https://github.com/johansenja/ruby-lsp-rails-factory-bot
   changelog_uri: https://github.com/johansenja/ruby-lsp-rails-factory-bot
 post_install_message:

data/lib/ruby_lsp/rails/factory_bot/server_extension.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "ruby_lsp_rails/server/extension"
-
-module RubyLsp
-  module Rails
-    module FactoryBot
-      class ServerExtension < RubyLsp::Rails::Server::Extension
-
-        before_start do
-          require "factory_bot"
-          ::FactoryBot.find_definitions
-          ::FactoryBot.factories.each(&:compile)
-        end
-
-        after_reload do
-          ::FactoryBot.find_definitions
-          ::FactoryBot.factories.each(&:compile)
-        end
-
-        command :factories do |params|
-          name = params[:name]
-          factories = ::FactoryBot.factories.select do |f|
-            name.nil? || name.empty? ? true : f.name.to_s.include?(params[:name])
-          end
-
-          factories.map do |fact|
-            model_class = fact.send :class_name
-            case model_class
-            when String, Symbol
-              model_class = model_class.to_s.camelize
-            end
-            {
-              name: fact.name,
-              model_class: model_class,
-            }
-          end
-        end
-
-        command :traits do |params|
-          factory = ::FactoryBot.factories[params[:factory_name]]
-
-          trait_name_partial = params[:name]
-          traits = factory.defined_traits.select { |tr| tr.name.to_s.include? trait_name_partial }.concat(
-            ::FactoryBot::Internal.traits.select { |tr|
-              (tr.klass == factory.send(:class_name) || !tr.klass) && tr.name.to_s.include?(trait_name_partial)
-            }
-          )
-
-          traits.map do |tr|
-            source_location = ServerExtension.block_for(tr)&.source_location
-            {
-              name: tr.name,
-              source_location: source_location,
-              source: ServerExtension.block_source(tr),
-              owner: tr.klass,
-            }
-          end
-        rescue KeyError
-        end
-
-        command :attributes do |params|
-          factory = ::FactoryBot.factories[params[:factory_name]]
-          name = params[:name]
-
-          attributes = factory.definition.declarations.select { |attr|
-            name.nil? || name.empty? ? true : attr.name.to_s.include?(name)
-          }
-
-          model_class = factory.send :class_name
-
-          attributes.map do |attribute|
-            source_location = ServerExtension.block_for(attribute)&.source_location
-            {
-              name: attribute.name,
-              owner: model_class.name,
-              type: ServerExtension.guess_attribute_type(attribute, model_class),
-              source_location: source_location,
-              source: ServerExtension.block_source(attribute),
-            }
-          end
-        rescue KeyError
-        end
-
-        class << self
-          def block_for(attr)
-            attr.instance_variable_get :@block
-          end
-
-          def block_source(attr)
-            blk = block_for(attr)
-
-            blk.source if blk.respond_to? :source
-          end
-
-          def guess_attribute_type(attribute, model_class)
-            if model_class.respond_to? :attribute_types
-              type = model_class.attribute_types[attribute.name.to_s]
-
-              return case type
-              when nil then nil
-              when ActiveModel::Type::String, ActiveModel::Type::ImmutableString
-                "String"
-              when ActiveModel::Type::Float
-                "Float"
-              when ActiveModel::Type::Integer
-                "Integer"
-              when ActiveModel::Type::Boolean
-                "boolean"
-              when ActiveModel::Type::Date
-                "Date"
-              when ActiveModel::Type::Time
-                "Time"
-              when ActiveModel::Type::DateTime
-                "DateTime"
-              else
-                type.type
-              end
-            end
-
-            return unless model_class.respond_to? :reflections
-
-            association = model_class.reflections[attribute.name.to_s]
-
-            association&.klass
-          end
-        end
-      end
-    end
-  end
-end