ruby-lsp-rails-factory-bot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41ed188af5e2b4b289442274d6538f7105ce3d0e93dd7340923b7f752c7b042b
+  data.tar.gz: a8b258fb2f0c05d17f614d3614515da65b29c04c95c17d7a39c2cd13bc1df261
+SHA512:
+  metadata.gz: dbcb7349c449d4d33076e65c04060ca179c150a204d9d6ce93b274bdd5f25357c98a32263a98092943f7845086d8117266394af00f086db21750bf4d83963f92
+  data.tar.gz: a2053e5de42267b86d927e7e0aa3fd4ab99475d9d82843086d4d91b1bb08dfa3efccf1a28aa79fbfd17990ee8d5bb330f99418590a561e878003b728f8ba39be

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Joseph Johansen
+
+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,35 @@
+# ruby-lsp-rails-factory-bot
+
+A ruby-lsp addon to integrate with [Factory bot](https://github.com/thoughtbot/factory_bot). Currently supports hover and completion
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add ruby-lsp-rails-factory-bot
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install ruby-lsp-rails-factory-bot
+
+Note that this currenlty uses a fork of ruby-lsp-rails (to extend its server to be able to provide factory information).
+
+## Usage
+
+Hover over an attribute or factory definition
+
+![lsp-factory-bot-hover](https://github.com/user-attachments/assets/6f570288-3cf3-4d12-acf9-71c86e834cd8)
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/johansenja/ruby-lsp-factory-bot.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+require "ruby_lsp_rails/runner_client"
+
+require_relative "completion"
+require_relative "hover"
+require_relative "server_extension"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      class Addon < ::RubyLsp::Addon
+        def activate(global_state, *)
+          @ruby_index = global_state.index
+        end
+
+        def deactivate(*); end
+
+        def name
+          "ruby-lsp-rails-factory-bot"
+        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)
+        end
+
+        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)
+        end
+
+        def workspace_did_change_watched_files(changes)
+          return unless changes.any? do |change|
+            change[:uri].match?(/(?:spec|test).+factor.+\.rb/)
+          end
+
+          RubyLsp::Rails::RunnerClient.instance.trigger_reload
+        end
+
+        private
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/internal"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      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
+          @server_client = server_client
+
+          dispatcher.register self, :on_call_node_enter
+        end
+
+        def on_call_node_enter(node)
+          return unless FACTORY_BOT_METHODS.include?(node.name) ||
+                        FACTORY_BOT_METHODS.include?(@node_context.parent.name)
+
+          case node.arguments
+          in [Prism::SymbolNode => factory_name_node]
+            handle_factory(factory_name_node, factory_name_node.value.to_s)
+
+          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
+            )
+          else
+            $stderr.write node.arguments
+            nil
+          end
+        rescue => e
+          $stderr.write(e, e.backtrace)
+        end
+
+        private
+
+        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)
+
+            @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
+              },
+            )
+          end
+        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)
+
+            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
+              },
+            )
+          end
+        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]
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/internal"
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      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
+          @server_client = server_client
+          @ruby_index = ruby_index
+
+          dispatcher.register self, :on_symbol_node_enter
+        end
+
+        def on_symbol_node_enter(symbol_node)
+          parent = @node_context.parent
+          call_node = @node_context.call_node
+
+          return unless call_node
+
+          # "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)
+            return
+          end
+
+          case call_node.arguments.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)
+          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
+          )&.find { |attr| attr[:name] == name }
+
+          return unless attribute
+
+          @response_builder.push(
+            "#{attribute[:name]} (#{attribute[:type]})",
+            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 }
+
+          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
+        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 }
+
+          return unless trait
+
+          @response_builder.push(
+            "#{trait[:name]} (trait of #{trait[:owner] || factory_name})",
+            category: :documentation
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# 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

data/lib/ruby_lsp_rails_factory_bot.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyLsp
+  module Rails
+    module FactoryBot
+      VERSION = "0.1.0".freeze
+    end
+  end
+end

data/sig/ruby_lsp/rails/factory_bot.rbs

@@ -0,0 +1,7 @@
+module RubyLsp
+  module Rails
+    module FactoryBot
+      VERSION: String
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ruby-lsp-rails-factory-bot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- johansenja
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.4.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.4.6
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.17
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby-lsp-rails extension for factorybot, providing factory, trait and
+  attribute completion, and more
+email:
+- 43235608+johansenja@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby_lsp/rails/factory_bot/addon.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.rb
+- sig/ruby_lsp/rails/factory_bot.rbs
+homepage: https://github.com/johansenja/ruby-lsp-factory-bot
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/johansenja/ruby-lsp-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:
+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.3.26
+signing_key:
+specification_version: 4
+summary: A ruby-lsp-rails extension for factorybot
+test_files: []