tapioca 0.16.7 → 0.16.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72d868353abd88ee0f1b29b098a89259e9ff1ec4248ae2a5d23f4cfa599f24b3
-  data.tar.gz: 721b57e0409ed03b3d10571cd49c7f258afd3fdd405cf6c61dfde5d339539169
+  metadata.gz: b2d6abd53e84e3b22cc6045597788c98d8f9571f486976baa8db4e5beb6ccd10
+  data.tar.gz: 5aa9162275489d2280f07419f74a4243c9ee813f922dd367e6260bae0fa37331
 SHA512:
-  metadata.gz: 8fab73b06ace7ab4c6efab4ac0d0b9566d629f4f02bbce249d8b786136c89212f2e35087402067a984b2ac40e29b8ea26aa4aa1f9caf0d543fbdee6938f87a68
-  data.tar.gz: '07609a1bd007962ff193ae2bdd2d1cf8c97b0504d4d3c0932697f45fd134833ddefca9197dc280a816598ee573ad2c4f0c314f1131929eea1a15e6eda3546b3c'
+  metadata.gz: 4fd946bacca4a56fe9f9befaa65404393719cacedf4877ce2e8ba0d9d5ab150d9957bea7298783a04e456170086b035b06b42b0312bc2840e1465631259801a1
+  data.tar.gz: '0825b9451bed3958b7132008993675de624753d41d5b7b267b50e8b7cf2900f344e5c666ac7726686ebfe9c997592dec6c02b5b2e1d14b144cdbaf837daeac08'

data/lib/ruby_lsp/tapioca/addon.rb

@@ -13,6 +13,7 @@ rescue LoadError
 end
 
 require "zlib"
+require "ruby_lsp/tapioca/run_gem_rbi_check"
 
 module RubyLsp
   module Tapioca
@@ -24,9 +25,10 @@ module RubyLsp
         super
 
         @global_state = T.let(nil, T.nilable(RubyLsp::GlobalState))
-        @rails_runner_client = T.let(nil, T.nilable(RubyLsp::Rails::RunnerClient))
+        @rails_runner_client = T.let(Rails::NullClient.new, RubyLsp::Rails::RunnerClient)
         @index = T.let(nil, T.nilable(RubyIndexer::Index))
         @file_checksums = T.let({}, T::Hash[String, String])
+        @lockfile_diff = T.let(nil, T.nilable(String))
         @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
       end
 
@@ -41,10 +43,17 @@ module RubyLsp
           # Get a handle to the Rails add-on's runtime client. The call to `rails_runner_client` will block this thread
           # until the server has finished booting, but it will not block the main LSP. This has to happen inside of a
           # thread
-          addon = T.cast(::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.3.17", "< 0.4"), ::RubyLsp::Rails::Addon)
+          addon = T.cast(::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.4.0", "< 0.5"), ::RubyLsp::Rails::Addon)
           @rails_runner_client = addon.rails_runner_client
           @outgoing_queue << Notification.window_log_message("Activating Tapioca add-on v#{version}")
           @rails_runner_client.register_server_addon(File.expand_path("server_addon.rb", __dir__))
+          @rails_runner_client.delegate_notification(
+            server_addon_name: "Tapioca",
+            request_name: "load_compilers_and_extensions",
+            workspace_path: @global_state.workspace_path,
+          )
+
+          run_gem_rbi_check
         rescue IncompatibleApiError
           # The requested version for the Rails add-on no longer matches. We need to upgrade and fix the breaking
           # changes
@@ -66,19 +75,39 @@ module RubyLsp
 
       sig { override.returns(String) }
       def version
-        "0.1.0"
+        "0.1.1"
       end
 
       sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
       def workspace_did_change_watched_files(changes)
         return unless T.must(@global_state).enabled_feature?(:tapiocaAddon)
-        return unless @rails_runner_client # Client is not ready
+        return unless @rails_runner_client.connected?
+
+        has_route_change = T.let(false, T::Boolean)
+        has_fixtures_change = T.let(false, T::Boolean)
+        needs_compiler_reload = T.let(false, T::Boolean)
 
         constants = changes.flat_map do |change|
           path = URI(change[:uri]).to_standardized_path
           next if path.end_with?("_test.rb", "_spec.rb")
           next unless file_updated?(change, path)
 
+          if File.fnmatch?("**/tapioca/**/compilers/**/*.rb", path, File::FNM_PATHNAME)
+            needs_compiler_reload = true
+            next
+          end
+
+          if File.basename(path) == "routes.rb" || File.fnmatch?("**/routes/**/*.rb", path, File::FNM_PATHNAME)
+            has_route_change = true
+            next
+          end
+
+          # NOTE: We only get notification for fixtures if ruby-lsp-rails is v0.3.31 or higher
+          if File.fnmatch("**/fixtures/**/*.yml{,.erb}", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+            has_fixtures_change = true
+            next
+          end
+
           entries = T.must(@index).entries_for(change[:uri])
           next unless entries
 
@@ -87,14 +116,33 @@ module RubyLsp
           end
         end.compact
 
-        return if constants.empty?
+        return if constants.empty? && !has_route_change && !has_fixtures_change && !needs_compiler_reload
 
         @rails_runner_client.trigger_reload
-        @rails_runner_client.delegate_notification(
-          server_addon_name: "Tapioca",
-          request_name: "dsl",
-          constants: constants,
-        )
+
+        if needs_compiler_reload
+          @rails_runner_client.delegate_notification(
+            server_addon_name: "Tapioca",
+            request_name: "reload_workspace_compilers",
+            workspace_path: T.must(@global_state).workspace_path,
+          )
+        end
+
+        if has_route_change
+          @rails_runner_client.delegate_notification(server_addon_name: "Tapioca", request_name: "route_dsl")
+        end
+
+        if has_fixtures_change
+          @rails_runner_client.delegate_notification(server_addon_name: "Tapioca", request_name: "fixtures_dsl")
+        end
+
+        if constants.any?
+          @rails_runner_client.delegate_notification(
+            server_addon_name: "Tapioca",
+            request_name: "dsl",
+            constants: constants,
+          )
+        end
       end
 
       private
@@ -127,6 +175,20 @@ module RubyLsp
 
         false
       end
+
+      sig { void }
+      def run_gem_rbi_check
+        gem_rbi_check = RunGemRbiCheck.new(T.must(@global_state).workspace_path)
+        gem_rbi_check.run
+
+        T.must(@outgoing_queue) << Notification.window_log_message(
+          gem_rbi_check.stdout,
+        ) unless gem_rbi_check.stdout.empty?
+        T.must(@outgoing_queue) << Notification.window_log_message(
+          gem_rbi_check.stderr,
+          type: Constant::MessageType::WARNING,
+        ) unless gem_rbi_check.stderr.empty?
+      end
     end
   end
 end

data/lib/ruby_lsp/tapioca/lockfile_diff_parser.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+require "bundler"
+
+module RubyLsp
+  module Tapioca
+    class LockfileDiffParser
+      GEM_NAME_PATTERN = /[\w\-]+/
+      DIFF_LINE_PATTERN = /[+-](.*#{GEM_NAME_PATTERN})\s*\(/
+      ADDED_LINE_PATTERN = /^\+.*#{GEM_NAME_PATTERN} \(.*\)/
+      REMOVED_LINE_PATTERN = /^-.*#{GEM_NAME_PATTERN} \(.*\)/
+
+      attr_reader :added_or_modified_gems
+      attr_reader :removed_gems
+
+      def initialize(diff_content, direct_dependencies: nil)
+        @diff_content = diff_content.lines
+        @current_dependencies = direct_dependencies ||
+          Bundler::LockfileParser.new(Bundler.default_lockfile.read).dependencies.keys
+        @added_or_modified_gems = parse_added_or_modified_gems
+        @removed_gems = parse_removed_gems
+      end
+
+      private
+
+      def parse_added_or_modified_gems
+        @diff_content
+          .filter_map { |line| extract_gem(line) if line.match?(ADDED_LINE_PATTERN) }
+          .uniq
+      end
+
+      def parse_removed_gems
+        @diff_content.filter_map do |line|
+          next unless line.match?(REMOVED_LINE_PATTERN)
+
+          gem = extract_gem(line)
+          next if @current_dependencies.include?(gem)
+
+          gem
+        end.uniq
+      end
+
+      def extract_gem(line)
+        line.match(DIFF_LINE_PATTERN)[1].strip
+      end
+    end
+  end
+end

data/lib/ruby_lsp/tapioca/run_gem_rbi_check.rb

@@ -0,0 +1,153 @@
+# typed: true
+# frozen_string_literal: true
+
+require "open3"
+require "ruby_lsp/tapioca/lockfile_diff_parser"
+
+module RubyLsp
+  module Tapioca
+    class RunGemRbiCheck
+      extend T::Sig
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :status
+
+      sig { params(project_path: String).void }
+      def initialize(project_path)
+        @project_path = project_path
+        @stdout = T.let("", String)
+        @stderr = T.let("", String)
+        @status = T.let(nil, T.nilable(Process::Status))
+      end
+
+      sig { void }
+      def run
+        return log_message("Not a git repository") unless git_repo?
+
+        cleanup_orphaned_rbis
+
+        if lockfile_changed?
+          generate_gem_rbis
+        end
+      end
+
+      private
+
+      attr_reader :project_path
+
+      sig { returns(T.nilable(T::Boolean)) }
+      def git_repo?
+        _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: project_path)
+        status.success?
+      end
+
+      sig { returns(T::Boolean) }
+      def lockfile_changed?
+        !lockfile_diff.empty?
+      end
+
+      sig { returns(Pathname) }
+      def lockfile
+        @lockfile ||= T.let(Pathname(project_path).join("Gemfile.lock"), T.nilable(Pathname))
+      end
+
+      sig { returns(String) }
+      def lockfile_diff
+        @lockfile_diff ||= T.let(read_lockfile_diff, T.nilable(String))
+      end
+
+      sig { returns(String) }
+      def read_lockfile_diff
+        return "" unless lockfile.exist?
+
+        execute_in_project_path("git", "diff", lockfile.to_s).strip
+      end
+
+      sig { void }
+      def generate_gem_rbis
+        parser = Tapioca::LockfileDiffParser.new(@lockfile_diff)
+        removed_gems = parser.removed_gems
+        added_or_modified_gems = parser.added_or_modified_gems
+
+        if added_or_modified_gems.any?
+          log_message("Identified lockfile changes, attempting to generate gem RBIs...")
+          execute_tapioca_gem_command(added_or_modified_gems)
+        elsif removed_gems.any?
+          remove_rbis(removed_gems)
+        end
+      end
+
+      sig { params(gems: T::Array[String]).void }
+      def execute_tapioca_gem_command(gems)
+        Bundler.with_unbundled_env do
+          stdout, stderr, status = T.unsafe(Open3).capture3(
+            "bundle",
+            "exec",
+            "tapioca",
+            "gem",
+            "--lsp_addon",
+            *gems,
+            chdir: project_path,
+          )
+
+          log_message(stdout) unless stdout.empty?
+          @stderr = stderr unless stderr.empty?
+          @status = status
+        end
+      end
+
+      sig { params(gems: T::Array[String]).void }
+      def remove_rbis(gems)
+        files = Dir.glob(
+          "sorbet/rbi/gems/{#{gems.join(",")}}@*.rbi",
+          base: project_path,
+        )
+        delete_files(files, "Removed RBIs for")
+      end
+
+      sig { void }
+      def cleanup_orphaned_rbis
+        untracked_files = git_ls_gem_rbis("--others", "--exclude-standard")
+        deleted_files = git_ls_gem_rbis("--deleted")
+
+        delete_files(untracked_files, "Deleted untracked RBIs")
+        restore_files(deleted_files, "Restored deleted RBIs")
+      end
+
+      sig { params(flags: T.untyped).returns(T::Array[String]) }
+      def git_ls_gem_rbis(*flags)
+        flags = T.unsafe(["git", "ls-files", *flags, "sorbet/rbi/gems/"])
+
+        execute_in_project_path(*flags)
+          .lines
+          .map(&:strip)
+      end
+
+      sig { params(files: T::Array[String], message: String).void }
+      def delete_files(files, message)
+        files_to_remove = files.map { |file| File.join(project_path, file) }
+        FileUtils.rm(files_to_remove)
+        log_message("#{message}: #{files.join(", ")}") unless files.empty?
+      end
+
+      sig { params(files: T::Array[String], message: String).void }
+      def restore_files(files, message)
+        execute_in_project_path("git", "checkout", "--pathspec-from-file=-", stdin: files.join("\n"))
+        log_message("#{message}: #{files.join(", ")}") unless files.empty?
+      end
+
+      sig { params(message: String).void }
+      def log_message(message)
+        @stdout += "#{message}\n"
+      end
+
+      def execute_in_project_path(*parts, stdin: nil)
+        options = { chdir: project_path }
+        options[:stdin_data] = stdin if stdin
+        stdout_and_stderr, _status = T.unsafe(Open3).capture2e(*parts, options)
+        stdout_and_stderr
+      end
+    end
+  end
+end

data/lib/ruby_lsp/tapioca/server_addon.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 require "tapioca/internal"
+require "tapioca/dsl/compilers/url_helpers"
+require "tapioca/dsl/compilers/active_record_fixtures"
 
 module RubyLsp
   module Tapioca
@@ -12,18 +14,62 @@ module RubyLsp
 
       def execute(request, params)
         case request
+        when "reload_workspace_compilers"
+          with_notification_wrapper("reload_workspace_compilers", "Reloading DSL compilers") do
+            @loader&.reload_custom_compilers
+          end
+        when "load_compilers_and_extensions"
+          # Load DSL extensions and compilers ahead of time, so that we don't have to pay the price of invoking
+          # `Gem.find_files` on every execution, which is quite expensive
+          @loader = ::Tapioca::Loaders::Dsl.new(
+            tapioca_path: ::Tapioca::TAPIOCA_DIR,
+            eager_load: false,
+            app_root: params[:workspace_path],
+            halt_upon_load_error: false,
+          )
+          @loader.load_dsl_extensions_and_compilers
         when "dsl"
           fork do
-            dsl(params)
+            with_notification_wrapper("dsl", "Generating DSL RBIs") do
+              dsl(params[:constants])
+            end
+          end
+        when "route_dsl"
+          fork do
+            with_notification_wrapper("route_dsl", "Generating route DSL RBIs") do
+              constants = ::Tapioca::Dsl::Compilers::UrlHelpers.gather_constants
+              dsl(constants.map(&:name), "--only=Tapioca::Dsl::Compilers::UrlHelpers", "ActiveSupportConcern")
+            end
+          end
+        when "fixtures_dsl"
+          fork do
+            with_notification_wrapper("fixture_dsl", "Generating fixture DSL RBIs") do
+              constants = ::Tapioca::Dsl::Compilers::ActiveRecordFixtures.gather_constants
+              dsl(constants.map(&:name), "--only=Tapioca::Dsl::Compilers::ActiveRecordFixtures")
+            end
           end
         end
       end
 
       private
 
-      def dsl(params)
+      def with_notification_wrapper(request_name, title, &block)
+        with_progress(request_name, title) do
+          with_notification_error_handling(request_name, &block)
+        end
+      end
+
+      def dsl(constants, *args)
         load("tapioca/cli.rb") # Reload the CLI to reset thor defaults between requests
-        ::Tapioca::Cli.start(["dsl", "--lsp_addon", "--workers=1"] + params[:constants])
+
+        # Order here is important to avoid having Thor confuse arguments. Do not put an array argument at the end before
+        # the list of constants
+        arguments = ["dsl"]
+        arguments.concat(args)
+        arguments.push("--lsp_addon", "--workers=1")
+        arguments.concat(constants)
+
+        ::Tapioca::Cli.start(arguments)
       end
     end
   end

data/lib/tapioca/commands/abstract_dsl.rb

@@ -118,12 +118,14 @@ module Tapioca
 
       sig { void }
       def load_application
+        # Loaded ahead of time when using the add-on to avoid reloading multiple times
+        return if @lsp_addon
+
         Loaders::Dsl.load_application(
           tapioca_path: @tapioca_path,
           eager_load: @requested_constants.empty? && @requested_paths.empty?,
           app_root: @app_root,
           halt_upon_load_error: @halt_upon_load_error,
-          lsp_addon: @lsp_addon,
         )
       end
 

data/lib/tapioca/dsl/compilers/active_record_relations.rb

@@ -372,7 +372,12 @@ module Tapioca
             return_type: "T.self_type",
           )
 
-          (CALCULATION_METHODS + [:size]).each do |method_name|
+          klass.create_method(
+            "size",
+            return_type: "T::Hash[T.untyped, Integer]",
+          )
+
+          CALCULATION_METHODS.each do |method_name|
             case method_name
             when :average, :maximum, :minimum
               klass.create_method(
@@ -400,9 +405,9 @@ module Tapioca
                 ],
                 return_type: "T::Hash[T.untyped, Integer]",
               )
-            when :sum, :size
+            when :sum
               klass.create_method(
-                method_name.to_s,
+                "sum",
                 parameters: [
                   create_opt_param("column_name", type: "T.nilable(T.any(String, Symbol))", default: "nil"),
                   create_block_param("block", type: "T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))"),

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -216,6 +216,11 @@ module Tapioca
                    ActiveRecord::Locking::LockingType === type
                }
             as_non_nilable_if_persisted_and_not_nullable("::Integer", column_nullability:)
+          when ->(type) {
+                 defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum) &&
+                   ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum === type
+               }
+            "::String"
           else
             as_non_nilable_if_persisted_and_not_nullable(
               ActiveModelTypeHelper.type_for(column_type),

data/lib/tapioca/gem/listeners/source_location.rb

@@ -57,7 +57,7 @@ module Tapioca
           # we can clear the gem version if the gem is the same one we are processing
           version = "" if gem == @pipeline.gem
 
-          uri = URI::Source.build(
+          uri = SourceURI.build(
             gem_name: gem.name,
             gem_version: version,
             path: path.to_s,

data/lib/tapioca/helpers/source_uri.rb

@@ -3,8 +3,8 @@
 
 require "uri/file"
 
-module URI
-  class Source < URI::File
+module Tapioca
+  class SourceURI < URI::File
     extend T::Sig
 
     COMPONENT = T.let(
@@ -37,7 +37,7 @@ module URI
           gem_version: T.nilable(String),
           path: String,
           line_number: T.nilable(String),
-        ).returns(URI::Source)
+        ).returns(T.attached_class)
       end
       def build(gem_name:, gem_version:, path:, line_number:)
         super(

data/lib/tapioca/loaders/dsl.rb

@@ -15,27 +15,20 @@ module Tapioca
             eager_load: T::Boolean,
             app_root: String,
             halt_upon_load_error: T::Boolean,
-            lsp_addon: T::Boolean,
           ).void
         end
         def load_application(
           tapioca_path:,
           eager_load: true,
           app_root: ".",
-          halt_upon_load_error: true,
-          lsp_addon: false
+          halt_upon_load_error: true
         )
-          loader = new(
+          new(
             tapioca_path: tapioca_path,
             eager_load: eager_load,
             app_root: app_root,
             halt_upon_load_error: halt_upon_load_error,
-          )
-          if lsp_addon
-            loader.load_dsl_extensions_and_compilers
-          else
-            loader.load
-          end
+          ).load
         end
       end
 
@@ -52,6 +45,27 @@ module Tapioca
         load_dsl_compilers
       end
 
+      sig { void }
+      def reload_custom_compilers
+        # Remove all loaded custom compilers
+        ::Tapioca::Dsl::Compiler.descendants.each do |compiler|
+          name = compiler.name
+          next unless name && @custom_compiler_paths.include?(Module.const_source_location(name)&.first)
+
+          *parts, unqualified_name = name.split("::")
+
+          if parts.empty?
+            Object.send(:remove_const, unqualified_name)
+          else
+            parts.join("::").safe_constantize.send(:remove_const, unqualified_name)
+          end
+        end
+
+        # Remove from $LOADED_FEATURES each workspace compiler file and then re-load
+        @custom_compiler_paths.each { |path| $LOADED_FEATURES.delete(path) }
+        load_custom_dsl_compilers
+      end
+
       protected
 
       sig do
@@ -64,6 +78,7 @@ module Tapioca
         @eager_load = eager_load
         @app_root = app_root
         @halt_upon_load_error = halt_upon_load_error
+        @custom_compiler_paths = T.let([], T::Array[String])
       end
 
       sig { void }
@@ -96,12 +111,7 @@ module Tapioca
         end
 
         # Load all custom compilers from the project
-        Dir.glob([
-          "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later
-          "#{@tapioca_path}/compilers/**/*.rb",
-        ]).each do |compiler|
-          require File.expand_path(compiler)
-        end
+        load_custom_dsl_compilers
 
         say("Done", :green)
       end
@@ -119,6 +129,17 @@ module Tapioca
 
         say("Done", :green)
       end
+
+      private
+
+      sig { void }
+      def load_custom_dsl_compilers
+        @custom_compiler_paths = Dir.glob([
+          "#{@tapioca_path}/generators/**/*.rb", # TODO: Here for backcompat, remove later
+          "#{@tapioca_path}/compilers/**/*.rb",
+        ])
+        @custom_compiler_paths.each { |compiler| require File.expand_path(compiler) }
+      end
     end
   end
 end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.16.7"
+  VERSION = "0.16.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.16.7
+  version: 0.16.9
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -10,7 +10,7 @@ authors:
 - Peter Zhu
 bindir: exe
 cert_chain: []
-date: 2025-01-09 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark
@@ -149,6 +149,8 @@ files:
 - README.md
 - exe/tapioca
 - lib/ruby_lsp/tapioca/addon.rb
+- lib/ruby_lsp/tapioca/lockfile_diff_parser.rb
+- lib/ruby_lsp/tapioca/run_gem_rbi_check.rb
 - lib/ruby_lsp/tapioca/server_addon.rb
 - lib/tapioca.rb
 - lib/tapioca/bundler_ext/auto_require_hook.rb
@@ -297,7 +299,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard
   library