Fix CI (#3)

Author: johansenja

.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

Gemfile.lock

@@ -25,6 +25,7 @@ GEM
     bigdecimal (3.1.8)
     concurrent-ruby (1.3.4)
     connection_pool (2.4.1)
+    diff-lcs (1.5.1)
     drb (2.2.1)
     factory_bot (6.4.6)
       activesupport (>= 5.0.0)
@@ -47,6 +48,19 @@ GEM
     regexp_parser (2.9.2)
     rexml (3.3.2)
       strscan
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.1)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
     rubocop (1.65.0)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
@@ -81,6 +95,7 @@ PLATFORMS
 
 DEPENDENCIES
   rake (~> 13.0)
+  rspec
   rubocop (~> 1.21)
   ruby-lsp-rails-factory-bot!
 

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]

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

lib/ruby_lsp/rails/factory_bot/addon.rb

@@ -6,10 +6,12 @@
 require_relative "completion"
 require_relative "hover"
 require_relative "addon_name"
+require_relative "../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, *)
           runner_client.register_server_addon(File.expand_path("server_addon.rb", __dir__))
@@ -49,7 +51,7 @@ def workspace_did_change_watched_files(changes)
         def runner_client
           @rails_addon ||= ::RubyLsp::Addon.get(
             "Ruby LSP Rails",
-            ::RubyLsp::Rails::FactoryBot::REQUIRED_RUBY_LSP_RAILS_VERSION
+            ::RubyLsp::Rails::FactoryBot::REQUIRED_RUBY_LSP_RAILS_VERSION,
           )
           @rails_addon.rails_runner_client
         end

lib/ruby_lsp/rails/factory_bot/addon_name.rb

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

lib/ruby_lsp/rails/factory_bot/completion.rb

@@ -7,17 +7,14 @@
 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
         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
@@ -27,112 +24,104 @@ def initialize(response_builder, node_context, dispatcher, server_client)
         end
 
         def on_call_node_enter(node)
-          return unless FACTORY_BOT_METHODS.include?(node.name) ||
-                        FACTORY_BOT_METHODS.include?(@node_context.parent.name)
+          return unless FactoryBot::FACTORY_BOT_METHODS.include?(node.name) ||
+                        FactoryBot::FACTORY_BOT_METHODS.include?(@node_context.parent.name)
+
+          process_arguments_pattern(node, node.arguments)
+        rescue StandardError => e
+          $stderr.write(e, e.backtrace)
+        end
+
+        private
 
-          case node.arguments
+        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)
-
-          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]
-            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
-            )
+            handle_trait(node_string_value(factory_name_node), node, 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)
           else
-            $stderr.write node.arguments
             nil
           end
-        rescue => e
-          $stderr.write(e, e.backtrace)
         end
 
-        private
+        def node_string_value(node)
+          node.value.to_s
+        end
 
         def handle_attribute(factory_name, node, value = "")
-          make_request(
-            :attributes,
-            factory_name: factory_name, name: value
-          )&.each do |attr|
-            label_details = Interface::CompletionItemLabelDetails.new(
-              description: attr[:type],
-            )
-            range = range_from_node(node)
+          range = range_from_node(node)
+          make_request(:attributes, factory_name: factory_name, name: value)&.each do |attr|
+            label_details = Interface::CompletionItemLabelDetails.new(description: attr[:type])
 
-            @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
-              },
-            )
+            @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 handle_trait(factory_name, node, value = "")
-          make_request(
-            :traits,
-            factory_name: factory_name, name: value
-          )&.each do |tr|
-            label_details = Interface::CompletionItemLabelDetails.new(
-              description: tr[:owner],
-            )
+          make_request(:traits, factory_name: factory_name, name: value)&.each do |tr|
+            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)
           end
         end
 
+        def serialise_trait(name, range, label_details)
+          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] },
+          )
+        end
+
         def handle_factory(node, name)
+          range = range_from_node(node)
           make_request(:factories, name: name)&.each do |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]
-              }
-            )
+            @response_builder << serialise_factory(fact[:name], fact[:model_class], range)
           end
         end
 
         def make_request(request_name, **params)
-          @server_client.delegate_request(
+          resp = @server_client.delegate_request(
             server_addon_name: FactoryBot::ADDON_NAME,
-            request_name: request_name,
-            **params
+            request_name: request_name.to_s,
+            **params,
+          )
+          resp[:result] if resp
+        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