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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28d0eed4aef05099e03470f4aae508ad687ce937db3d080289e5acf44d71b4a1
-  data.tar.gz: cfa4ac0edb00841d67a6052a90ecea3c0649420fbe7acc00dcf0d1df0aca8651
+  metadata.gz: 01d1b4f936612100587a05ace6ca2c46fd654484c7d1125245e3c3afd7ce2fb2
+  data.tar.gz: cd15946860a27dbaa31ba14b8f429c5afb7f4bd21a9eeb1aca0f01411006bebf
 SHA512:
-  metadata.gz: 69904e9e37c3a82cbc7f6c098d8c0c72fce15ae5e4c6a6cbf4a596d60b178be7e1577411776c191605ba0d359aef7c685dffc30ba756111f006b9b3873a44489
-  data.tar.gz: bbaf4f6cad8a9e394b423c6c49a029fcd768543473e1165676780813e588de3d5518020bd1f0c9b0d1a11cea7d2cd2502e18ad5b0b4e8b90da6700774e639032
+  metadata.gz: e09bd8301b1003c30ba6efdba15c6c945f4f0ca0adbda81e8f290bcf4a0dff480c1c482e28499a5477d80a656a358018788a6a5022441da8698c940272089e2c
+  data.tar.gz: 3b145ca533d21b291cd545dde273f4c6f333ea255beca536c01f44e488b02a813d4beab114a4d4269b3c0add785b020df3cc875777d28183b2f338a7005a38df

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/lib/ruby_lsp/rails/factory_bot/addon.rb

@@ -27,15 +27,10 @@ module RubyLsp
           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)
-
-        #   ensure_addon_registered!
-
-        #   Completion.new(response_builder, node_context, dispatcher, runner_client)
-        # end
+        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)
@@ -75,18 +70,6 @@ module RubyLsp
           @rails_addon.rails_runner_client
         end
 
-        FACTORY_BOT_METHODS = %i[
-          create
-          build
-          build_stubbed
-          attributes_for
-        ].flat_map { |attr| [attr, :"#{attr}_list", :"#{attr}_pair"] }.freeze
-
-        def factory_bot_call_args?(node_context)
-          node_context.call_node && FACTORY_BOT_METHODS.include?(node_context.call_node.name)
-          true
-        end
-
         def log(msg)
           return if !@outgoing_queue || @outgoing_queue.closed?
 

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

@@ -8,11 +8,7 @@ module RubyLsp
   module Rails
     module FactoryBot
       # The listener that is created when the user requests autocomplete at the relevant time.
-      #
-      # NOTE: autocompletion is only triggered on certain node types - almost exclusively call nodes
-      # and constants IIRC, so you cannot currently receive autocomplete options for symbols (eg.
-      # factory or trait names) :/
-      class Completion
+      class Completion # rubocop:disable Metrics/ClassLength
         include RubyLsp::Requests::Support::Common
 
         def initialize(response_builder, node_context, dispatcher, server_client)
@@ -24,10 +20,12 @@ module RubyLsp
         end
 
         def on_call_node_enter(node)
-          return unless FactoryBot::FACTORY_BOT_METHODS.include?(node.name) ||
-                        FactoryBot::FACTORY_BOT_METHODS.include?(@node_context.parent.name)
+          call_node = @node_context.call_node
+          return unless call_node
 
-          process_arguments_pattern(node, node.arguments)
+          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
@@ -40,26 +38,50 @@ module RubyLsp
             handle_factory(factory_name_node, node_string_value(factory_name_node))
 
           in [Prism::SymbolNode => factory_name_node, *, Prism::SymbolNode => trait_node]
-            handle_trait(node_string_value(factory_name_node), node, node_string_value(trait_node))
+            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::KeywordHashNode => _kw_node] |
             [Prism::SymbolNode => _factory_name_node, *, Prism::HashNode => _kw_node] |
             [Prism::SymbolNode => _factory_name_node, *, Prism::CallNode => _call_node]
 
-            attr_name = _call_node ? _call_node.message : _kw_node.elements.last.key.value&.to_s
-            handle_attribute(node_string_value(_factory_name_node), node, attr_name)
+            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
             nil
           end
         end
 
         def node_string_value(node)
-          node.value.to_s
+          case node
+          when Prism::CallNode
+            node.name.to_s
+          when Prism::SymbolNode
+            node.value.to_s
+          when nil
+            ""
+          end
+        end
+
+        def gather_already_used_attrs(kw_node)
+          attrs = Set.new
+          return attrs unless kw_node
+
+          kw_node.elements.each do |e|
+            attrs.add(node_string_value(e.key))
+          end
+
+          attrs
         end
 
-        def handle_attribute(factory_name, node, value = "")
+        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)
@@ -77,24 +99,39 @@ module RubyLsp
           )
         end
 
-        def handle_trait(factory_name, node, value = "")
+        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 << serialise_trait(name, range, label_details)
+            @response_builder << serialise_trait(name, range, label_details, tr[:owner])
           end
         end
 
-        def serialise_trait(name, range, label_details)
+        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: tr[:owner] },
+            data: { owner_name: nil, guessed_type: owner },
           )
         end
 

data/lib/ruby_lsp_rails_factory_bot.rb

@@ -3,7 +3,7 @@
 module RubyLsp
   module Rails
     module FactoryBot
-      VERSION = "0.2.0"
+      VERSION = "0.3.0"
       REQUIRED_RUBY_LSP_RAILS_VERSION = "~> 0.4"
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails-factory-bot
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - johansenja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-20 00:00:00.000000000 Z
+date: 2025-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_bot