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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28d0eed4aef05099e03470f4aae508ad687ce937db3d080289e5acf44d71b4a1
-  data.tar.gz: cfa4ac0edb00841d67a6052a90ecea3c0649420fbe7acc00dcf0d1df0aca8651
+  metadata.gz: 36e804a6875a0e627b7723e82840cbd502cc7dd4d352a740e9d7917379a2929a
+  data.tar.gz: e87ef45262a4740710ceae3229b7f681faaf002987d5a611f355e80a4e883378
 SHA512:
-  metadata.gz: 69904e9e37c3a82cbc7f6c098d8c0c72fce15ae5e4c6a6cbf4a596d60b178be7e1577411776c191605ba0d359aef7c685dffc30ba756111f006b9b3873a44489
-  data.tar.gz: bbaf4f6cad8a9e394b423c6c49a029fcd768543473e1165676780813e588de3d5518020bd1f0c9b0d1a11cea7d2cd2502e18ad5b0b4e8b90da6700774e639032
+  metadata.gz: a60ac6a177b638d4ecb930c2ccb0c0f59f1d457b421ebdcd6b64f55efe26aa179d8de68b80498b7701929c34a357410bc1e0d195835b51dc95312834648790ce
+  data.tar.gz: aa3ea96af8da24ef905db823967fac046a2a6900bb1f39033d8cbd20a5e284003df43669272ad48ff9eec49c5a433be534145d0855171d4423443114a9b2cc02

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,23 +27,13 @@ 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)
-          unless @addon_registered
-            register_addon!
-            return
-          end
-
+          register_addon!
           Hover.new(response_builder, node_context, dispatcher, runner_client, @ruby_index)
         end
 
@@ -75,18 +65,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/hover.rb

@@ -43,8 +43,12 @@ module RubyLsp
           in [^symbol_node, *]
             handle_factory(symbol_node)
           in [Prism::SymbolNode => _factory_node, *, ^symbol_node] |
+             [Prism::SymbolNode => _factory_node, *, ^symbol_node, Prism::KeywordHashNode] |
+             [Prism::SymbolNode => _factory_node, *, ^symbol_node, Prism::HashNode] |
              [Prism::SymbolNode => _factory_node, ^symbol_node, *] |
-             [Prism::SymbolNode => _factory_node, Integer, ^symbol_node, *]
+             [Prism::SymbolNode => _factory_node, Prism::IntegerNode, ^symbol_node, *] |
+             [Prism::SymbolNode => _factory_node, Prism::IntegerNode, *, ^symbol_node, Prism::KeywordHashNode] |
+             [Prism::SymbolNode => _factory_node, Prism::IntegerNode, *, ^symbol_node, Prism::HashNode]
 
             handle_trait(symbol_node, _factory_node)
 
@@ -88,6 +92,11 @@ module RubyLsp
           @response_builder.push(hint, category: :documentation)
         end
 
+        def trait_tooltip(trait, factory_name)
+          source = trait[:source]&.length&.positive? ? trait[:source] : nil
+          source || "#{trait[:name]} (trait of #{trait[:owner] || factory_name})"
+        end
+
         def handle_trait(symbol_node, factory_node)
           factory_name = factory_node.value.to_s
           trait_name = symbol_node.value.to_s
@@ -98,10 +107,7 @@ module RubyLsp
 
           return unless trait
 
-          @response_builder.push(
-            "#{trait[:name]} (trait of #{trait[:owner] || factory_name})",
-            category: :documentation,
-          )
+          @response_builder.push(trait_tooltip(trait, factory_name), category: :documentation)
         end
 
         def make_request(request_name, **params)

data/lib/ruby_lsp_rails_factory_bot.rb

@@ -3,7 +3,7 @@
 module RubyLsp
   module Rails
     module FactoryBot
-      VERSION = "0.2.0"
+      VERSION = "0.4.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.4.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