tapioca 0.16.4 → 0.16.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80c01f44b0600c3a471756da73e43322f23a951c8f3ebc15c922173a0ccf4d3c
-  data.tar.gz: c778cfa78b0494513f5ad329e432c534486c3ba75fcf83969462a874c7dc7654
+  metadata.gz: 5a42a478b0396f43dd9e6505c18ac69ca8c32e6ef00b298e6d6e4a8c12536b17
+  data.tar.gz: f24ab38ee1d78f1633f7d580ea5be8f93e13c9c6550d11b5d5bc4171d974929b
 SHA512:
-  metadata.gz: f12a7fbe0d64109a5de03d8a98f564413bee79dc0db1ced8c1eaeae8dae73e68c73e8e76a188a06ddfefa333b11024d606359b7f706d13e15dacea081b0a19ea
-  data.tar.gz: 99ef8194c8dab5e776b591992aefa8b59b0b8e2d8927caecfc68d63bf7bb4c7687a92af772c6f8ac5fcfbdd8ebe1f9c1b748a2334b8207d233939d35d02d2b26
+  metadata.gz: f623d3b5e66a081728d9ae4b3dde4c6c976829ffbd6e606a64def2e8aff489c09911396ca72146c901f72a11d432d6c86ae840e278b8d85fd8ee756e97776542
+  data.tar.gz: e7686bcfed28858bfb8f162ee0bd8a7c9a6cdf286c7227a86032025934b04fa72c29f21c41d7a3c5668edb8aad2d39bf2808a2d98799a7434e94aa9b921c3cf8

data/README.md

@@ -489,8 +489,7 @@ Options:
                                                                                                    # Default: false
   -q,        [--quiet], [--no-quiet], [--skip-quiet]                                               # Suppresses file creation output
                                                                                                    # Default: false
-  -w,        [--workers=N]                                                                         # Number of parallel workers to use when generating RBIs (default: 2)
-                                                                                                   # Default: 2
+  -w,        [--workers=N]                                                                         # Number of parallel workers to use when generating RBIs (default: auto)
              [--rbi-max-line-length=N]                                                             # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
                                                                                                    # Default: 120
   -e,        [--environment=ENVIRONMENT]                                                           # The Rack/Rails environment to use when generating RBIs
@@ -949,7 +948,7 @@ dsl:
   exclude: []
   verify: false
   quiet: false
-  workers: 2
+  workers: 1
   rbi_max_line_length: 120
   environment: development
   list_compilers: false
@@ -1000,7 +999,16 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/Shopif
 
 ### DSL compilers
 
-Contributions to existing DSL compilers are welcome. However, new compilers that support DSLs for gems other than Rails should live outside of Tapioca. Please refer to [writing custom dsl compilers](https://github.com/Shopify/tapioca?tab=readme-ov-file#writing-custom-dsl-compilers) for more information.
+Tapioca ships with a small collection of high quality DSL compilers for popular Ruby gems that are used heavily at Shopify, like Rails and GraphQL. We encourage the community to contribute new DSL compilers, though they shouldn't necessarily live in the Tapioca repo itself.
+
+It's best for DSL compilers to be contributed directly to gems they apply to ([example](https://github.com/Shopify/measured/tree/main/lib/tapioca/dsl/compilers)). This way, when changes are made to the gem's DSL, the gem's DSL compiler can be updated at the same time and be versioned/released together.
+
+If an upstream gem's maintainers don't wish to host a DSL compiler themselves, you can propose contributing it to:
+
+1. Tapioca, if it's a gem that Shopify uses (ask us in an issue or PR)
+2. A third party DSL compiler repository, like [AngelList/Boba](https://github.com/angellist/boba). These are not supported by Shopify.
+
+For help writing a DSL compiler, please refer to [writing custom dsl compilers](https://github.com/Shopify/tapioca?tab=readme-ov-file#writing-custom-dsl-compilers).
 
 ## License
 

data/exe/tapioca

@@ -20,6 +20,11 @@ unless ENV["ENFORCE_TYPECHECKING"] == "1"
   end
 end
 
+unless defined?(Bundler)
+  puts "Warning: You're running tapioca without Bundler. This isn't recommended and may cause issues. " \
+    "Please use the provided binstub through `bin/tapioca` instead."
+end
+
 require_relative "../lib/tapioca/internal"
 
 Tapioca::Cli.start(ARGV)

data/lib/ruby_lsp/tapioca/addon.rb

@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.22.1", "< 0.23")
+
+begin
+  # The Tapioca add-on depends on the Rails add-on to add a runtime component to the runtime server. We can allow the
+  # add-on to work outside of a Rails context in the future, but that may require Tapioca spawning its own runtime
+  # server
+  require "ruby_lsp/ruby_lsp_rails/runner_client"
+rescue LoadError
+  return
+end
+
+require "zlib"
+
+module RubyLsp
+  module Tapioca
+    class Addon < ::RubyLsp::Addon
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super
+
+        @global_state = T.let(nil, T.nilable(RubyLsp::GlobalState))
+        @rails_runner_client = T.let(nil, T.nilable(RubyLsp::Rails::RunnerClient))
+        @index = T.let(nil, T.nilable(RubyIndexer::Index))
+        @file_checksums = T.let({}, T::Hash[String, String])
+        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
+      end
+
+      sig { override.params(global_state: RubyLsp::GlobalState, outgoing_queue: Thread::Queue).void }
+      def activate(global_state, outgoing_queue)
+        @global_state = global_state
+        return unless @global_state.enabled_feature?(:tapiocaAddon)
+
+        @index = @global_state.index
+        @outgoing_queue = outgoing_queue
+        Thread.new do
+          # 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)
+          @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__))
+        rescue IncompatibleApiError
+          # The requested version for the Rails add-on no longer matches. We need to upgrade and fix the breaking
+          # changes
+          @outgoing_queue << Notification.window_log_message(
+            "IncompatibleApiError: Cannot activate Tapioca LSP add-on",
+            type: Constant::MessageType::WARNING,
+          )
+        end
+      end
+
+      sig { override.void }
+      def deactivate
+      end
+
+      sig { override.returns(String) }
+      def name
+        "Tapioca"
+      end
+
+      sig { override.returns(String) }
+      def version
+        "0.1.0"
+      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
+
+        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)
+
+          entries = T.must(@index).entries_for(path)
+          next unless entries
+
+          entries.filter_map do |entry|
+            entry.name if entry.class == RubyIndexer::Entry::Class || entry.class == RubyIndexer::Entry::Module
+          end
+        end.compact
+
+        return if constants.empty?
+
+        @rails_runner_client.trigger_reload
+        @rails_runner_client.delegate_notification(
+          server_addon_name: "Tapioca",
+          request_name: "dsl",
+          constants: constants,
+        )
+      end
+
+      private
+
+      sig { params(change: T::Hash[Symbol, T.untyped], path: String).returns(T::Boolean) }
+      def file_updated?(change, path)
+        case change[:type]
+        when Constant::FileChangeType::CREATED
+          @file_checksums[path] = Zlib.crc32(File.read(path)).to_s
+          return true
+        when Constant::FileChangeType::CHANGED
+          current_checksum = Zlib.crc32(File.read(path)).to_s
+          if @file_checksums[path] == current_checksum
+            T.must(@outgoing_queue) << Notification.window_log_message(
+              "File has not changed. Skipping #{path}",
+              type: Constant::MessageType::INFO,
+            )
+          else
+            @file_checksums[path] = current_checksum
+            return true
+          end
+        when Constant::FileChangeType::DELETED
+          @file_checksums.delete(path)
+        else
+          T.must(@outgoing_queue) << Notification.window_log_message(
+            "Unexpected file change type: #{change[:type]}",
+            type: Constant::MessageType::WARNING,
+          )
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/ruby_lsp/tapioca/server_addon.rb

@@ -0,0 +1,30 @@
+# typed: false
+# frozen_string_literal: true
+
+require "tapioca/internal"
+
+module RubyLsp
+  module Tapioca
+    class ServerAddon < ::RubyLsp::Rails::ServerAddon
+      def name
+        "Tapioca"
+      end
+
+      def execute(request, params)
+        case request
+        when "dsl"
+          fork do
+            dsl(params)
+          end
+        end
+      end
+
+      private
+
+      def dsl(params)
+        load("tapioca/cli.rb") # Reload the CLI to reset thor defaults between requests
+        ::Tapioca::Cli.start(["dsl", "--lsp_addon", "--workers=1"] + params[:constants])
+      end
+    end
+  end
+end

data/lib/tapioca/cli.rb

@@ -111,8 +111,7 @@ module Tapioca
     option :workers,
       aliases: ["-w"],
       type: :numeric,
-      desc: "Number of parallel workers to use when generating RBIs (default: 2)",
-      default: 2
+      desc: "Number of parallel workers to use when generating RBIs (default: auto)"
     option :rbi_max_line_length,
       type: :numeric,
       desc: "Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped",
@@ -144,6 +143,11 @@ module Tapioca
       type: :hash,
       desc: "Options to pass to the DSL compilers",
       default: {}
+    option :lsp_addon,
+      type: :boolean,
+      desc: "Generate DSL RBIs from the LSP add-on. Internal to Tapioca and not intended for end-users",
+      default: false,
+      hide: true
     def dsl(*constant_or_paths)
       set_environment(options)
 
@@ -166,6 +170,7 @@ module Tapioca
         app_root: options[:app_root],
         halt_upon_load_error: options[:halt_upon_load_error],
         compiler_options: options[:compiler_options],
+        lsp_addon: options[:lsp_addon],
       }
 
       command = if options[:verify]
@@ -261,6 +266,11 @@ module Tapioca
       type: :boolean,
       desc: "Halt upon a load error while loading the Rails application",
       default: true
+    option :lsp_addon,
+      type: :boolean,
+      desc: "Generate Gem RBIs from the LSP add-on. Internal to Tapioca and not intended for end-users",
+      default: false,
+      hide: true
     def gem(*gems)
       set_environment(options)
 
@@ -295,6 +305,7 @@ module Tapioca
         dsl_dir: options[:dsl_dir],
         rbi_formatter: rbi_formatter(options),
         halt_upon_load_error: options[:halt_upon_load_error],
+        lsp_addon: options[:lsp_addon],
       }
 
       command = if verify

data/lib/tapioca/commands/abstract_dsl.rb

@@ -28,6 +28,7 @@ module Tapioca
           app_root: String,
           halt_upon_load_error: T::Boolean,
           compiler_options: T::Hash[String, T.untyped],
+          lsp_addon: T::Boolean,
         ).void
       end
       def initialize(
@@ -47,7 +48,8 @@ module Tapioca
         rbi_formatter: DEFAULT_RBI_FORMATTER,
         app_root: ".",
         halt_upon_load_error: true,
-        compiler_options: {}
+        compiler_options: {},
+        lsp_addon: false
       )
         @requested_constants = requested_constants
         @requested_paths = requested_paths
@@ -66,6 +68,7 @@ module Tapioca
         @halt_upon_load_error = halt_upon_load_error
         @skip_constant = skip_constant
         @compiler_options = compiler_options
+        @lsp_addon = lsp_addon
 
         super()
       end
@@ -74,6 +77,10 @@ module Tapioca
 
       sig { params(outpath: Pathname, quiet: T::Boolean).returns(T::Set[Pathname]) }
       def generate_dsl_rbi_files(outpath, quiet:)
+        if @lsp_addon
+          pipeline.active_compilers.each(&:reset_state)
+        end
+
         existing_rbi_files = existing_rbi_filenames(all_requested_constants)
 
         generated_files = pipeline.run do |constant, contents|
@@ -116,6 +123,7 @@ module Tapioca
           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
 
@@ -133,6 +141,7 @@ module Tapioca
           skipped_constants: constantize(@skip_constant, ignore_missing: true),
           number_of_workers: @number_of_workers,
           compiler_options: @compiler_options,
+          lsp_addon: @lsp_addon,
         )
       end
 
@@ -170,7 +179,9 @@ module Tapioca
           raise Thor::Error, ""
         end
 
-        processable_constants.map { |_, constant| constant }
+        processable_constants
+          .map { |_, constant| constant }
+          .grep(Module)
       end
 
       sig { params(compiler_names: T::Array[String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }

data/lib/tapioca/commands/abstract_gem.rb

@@ -27,6 +27,7 @@ module Tapioca
           dsl_dir: String,
           rbi_formatter: RBIFormatter,
           halt_upon_load_error: T::Boolean,
+          lsp_addon: T.nilable(T::Boolean),
         ).void
       end
       def initialize(
@@ -45,7 +46,8 @@ module Tapioca
         auto_strictness: true,
         dsl_dir: DEFAULT_DSL_DIR,
         rbi_formatter: DEFAULT_RBI_FORMATTER,
-        halt_upon_load_error: true
+        halt_upon_load_error: true,
+        lsp_addon: false
       )
         @gem_names = gem_names
         @exclude = exclude
@@ -59,6 +61,7 @@ module Tapioca
         @auto_strictness = auto_strictness
         @dsl_dir = dsl_dir
         @rbi_formatter = rbi_formatter
+        @lsp_addon = lsp_addon
 
         super()
 
@@ -73,39 +76,6 @@ module Tapioca
 
       private
 
-      sig { params(gem_names: T::Array[String]).returns(T::Array[Gemfile::GemSpec]) }
-      def gems_to_generate(gem_names)
-        return @bundle.dependencies if gem_names.empty?
-
-        gem_names.each_with_object([]) do |gem_name, gems|
-          gem = @bundle.gem(gem_name)
-
-          if gem.nil?
-            raise Thor::Error, set_color("Error: Cannot find gem '#{gem_name}'", :red)
-          end
-
-          gems.concat(gem_dependencies(gem)) if @include_dependencies
-          gems << gem
-        end
-      end
-
-      sig do
-        params(
-          gem: Gemfile::GemSpec,
-          dependencies: T::Array[Gemfile::GemSpec],
-        ).returns(T::Array[Gemfile::GemSpec])
-      end
-      def gem_dependencies(gem, dependencies = [])
-        direct_dependencies = gem.dependencies.filter_map { |dependency| @bundle.gem(dependency.name) }
-        gems = dependencies | direct_dependencies
-
-        if direct_dependencies.empty?
-          gems
-        else
-          direct_dependencies.reduce(gems) { |result, gem| gem_dependencies(gem, result) }
-        end
-      end
-
       sig { params(gem: Gemfile::GemSpec).void }
       def compile_gem_rbi(gem)
         gem_name = set_color(gem.name, :yellow, :bold)

data/lib/tapioca/commands/dsl_generate.rb

@@ -19,7 +19,7 @@ module Tapioca
         purge_stale_dsl_rbi_files(rbi_files_to_purge)
         say("Done", :green)
 
-        if @auto_strictness
+        if @auto_strictness && !@lsp_addon
           say("")
           validate_rbi_files(
             command: default_command(:dsl, all_requested_constants.join(" ")),

data/lib/tapioca/commands/gem_generate.rb

@@ -46,6 +46,41 @@ module Tapioca
       ensure
         GitAttributes.create_generated_attribute_file(@outpath)
       end
+
+      sig { params(gem_names: T::Array[String]).returns(T::Array[Gemfile::GemSpec]) }
+      def gems_to_generate(gem_names)
+        return @bundle.dependencies if gem_names.empty?
+
+        (gem_names - @exclude).each_with_object([]) do |gem_name, gems|
+          gem = @bundle.gem(gem_name)
+
+          if gem.nil?
+            next if @lsp_addon
+
+            raise Thor::Error, set_color("Error: Cannot find gem '#{gem_name}'", :red)
+          end
+
+          gems.concat(gem_dependencies(gem)) if @include_dependencies
+          gems << gem
+        end
+      end
+
+      sig do
+        params(
+          gem: Gemfile::GemSpec,
+          dependencies: T::Array[Gemfile::GemSpec],
+        ).returns(T::Array[Gemfile::GemSpec])
+      end
+      def gem_dependencies(gem, dependencies = [])
+        direct_dependencies = gem.dependencies.filter_map { |dependency| @bundle.gem(dependency.name) }
+        gems = dependencies | direct_dependencies
+
+        if direct_dependencies.empty?
+          gems
+        else
+          direct_dependencies.reduce(gems) { |result, gem| gem_dependencies(gem, result) }
+        end
+      end
     end
   end
 end

data/lib/tapioca/dsl/compiler.rb

@@ -51,6 +51,13 @@ module Tapioca
           @@requested_constants = constants # rubocop:disable Style/ClassVars
         end
 
+        sig { void }
+        def reset_state
+          @processable_constants = nil
+          @all_classes = nil
+          @all_modules = nil
+        end
+
         private
 
         sig do
@@ -74,11 +81,7 @@ module Tapioca
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
           @all_classes ||= T.let(
-            if @@requested_constants.any?
-              @@requested_constants.grep(Class)
-            else
-              ObjectSpace.each_object(Class)
-            end,
+            all_modules.grep(Class).freeze,
             T.nilable(T::Enumerable[T::Class[T.anything]]),
           )
         end
@@ -87,10 +90,10 @@ module Tapioca
         def all_modules
           @all_modules ||= T.let(
             if @@requested_constants.any?
-              @@requested_constants.select { |k| k.is_a?(Module) }
+              @@requested_constants.grep(Module)
             else
-              ObjectSpace.each_object(Module)
-            end,
+              ObjectSpace.each_object(Module).to_a
+            end.freeze,
             T.nilable(T::Enumerable[Module]),
           )
         end

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

@@ -101,26 +101,26 @@ module Tapioca
 
         sig { params(attribute_type_value: T.untyped).returns(::String) }
         def type_for(attribute_type_value)
-          type = case attribute_type_value
+          case attribute_type_value
           when ActiveModel::Type::Boolean
-            "T::Boolean"
+            as_nilable_type("T::Boolean")
           when ActiveModel::Type::Date
-            "::Date"
+            as_nilable_type("::Date")
           when ActiveModel::Type::DateTime, ActiveModel::Type::Time
-            "::Time"
+            as_nilable_type("::Time")
           when ActiveModel::Type::Decimal
-            "::BigDecimal"
+            as_nilable_type("::BigDecimal")
           when ActiveModel::Type::Float
-            "::Float"
+            as_nilable_type("::Float")
           when ActiveModel::Type::Integer
-            "::Integer"
+            as_nilable_type("::Integer")
           when ActiveModel::Type::String
-            "::String"
+            as_nilable_type("::String")
           else
-            Helpers::ActiveModelTypeHelper.type_for(attribute_type_value)
+            type = Helpers::ActiveModelTypeHelper.type_for(attribute_type_value)
+            type = as_nilable_type(type) if Helpers::ActiveModelTypeHelper.assume_nilable?(attribute_type_value)
+            type
           end
-
-          as_nilable_type(type)
         end
 
         sig { params(klass: RBI::Scope, method: String, type: String).void }

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

@@ -210,10 +210,6 @@ module Tapioca
             query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
             # Remove the ones we know are private API
             query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-            # Remove "group" which needs a custom return type for GroupChains
-            query_methods -= [:group]
-            # Remove "where" which needs a custom return type for WhereChains
-            query_methods -= [:where]
             # Remove the methods that ...
             query_methods
               .grep_v(/_clause$/) # end with "_clause"
@@ -376,7 +372,7 @@ module Tapioca
             return_type: "T.self_type",
           )
 
-          CALCULATION_METHODS.each do |method_name|
+          (CALCULATION_METHODS + [:size]).each do |method_name|
             case method_name
             when :average, :maximum, :minimum
               klass.create_method(
@@ -404,9 +400,9 @@ module Tapioca
                 ],
                 return_type: "T::Hash[T.untyped, Integer]",
               )
-            when :sum
+            when :sum, :size
               klass.create_method(
-                "sum",
+                method_name.to_s,
                 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))"),
@@ -419,7 +415,7 @@ module Tapioca
 
         sig { void }
         def create_relation_where_chain_class
-          model.create_class(RelationWhereChainClassName, superclass_name: RelationClassName) do |klass|
+          model.create_class(RelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, RelationClassName)
             klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
           end
@@ -427,10 +423,7 @@ module Tapioca
 
         sig { void }
         def create_association_relation_where_chain_class
-          model.create_class(
-            AssociationRelationWhereChainClassName,
-            superclass_name: AssociationRelationClassName,
-          ) do |klass|
+          model.create_class(AssociationRelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, AssociationRelationClassName)
             klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
           end
@@ -560,27 +553,21 @@ module Tapioca
         sig { void }
         def create_relation_methods
           create_relation_method("all")
-          create_relation_method(
-            "group",
-            parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
-            ],
-            relation_return_type: RelationGroupChainClassName,
-            association_return_type: AssociationRelationGroupChainClassName,
-          )
-          create_relation_method(
-            "where",
-            parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
-            ],
-            relation_return_type: RelationWhereChainClassName,
-            association_return_type: AssociationRelationWhereChainClassName,
-          )
 
           QUERY_METHODS.each do |method_name|
             case method_name
+            when :where
+              create_where_relation_method
+            when :group
+              create_relation_method(
+                "group",
+                parameters: [
+                  create_rest_param("args", type: "T.untyped"),
+                  create_block_param("blk", type: "T.untyped"),
+                ],
+                relation_return_type: RelationGroupChainClassName,
+                association_return_type: AssociationRelationGroupChainClassName,
+              )
             when :distinct
               create_relation_method(
                 method_name.to_s,
@@ -599,6 +586,22 @@ module Tapioca
                 parameters: parameters,
                 return_type: return_type,
               )
+            when :select
+              [relation_methods_module, association_relation_methods_module].each do |mod|
+                mod.create_method(method_name.to_s) do |method|
+                  method.add_rest_param("args")
+                  method.add_block_param("blk")
+
+                  method.add_sig do |sig|
+                    sig.add_param("args", "T.untyped")
+                    sig.return_type = mod == relation_methods_module ? RelationClassName : AssociationRelationClassName
+                  end
+                  method.add_sig do |sig|
+                    sig.add_param("blk", "T.proc.params(record: #{constant_name}).returns(T::Boolean)")
+                    sig.return_type = "T::Array[#{constant_name}]"
+                  end
+                end
+              end
             else
               create_relation_method(
                 method_name,
@@ -1056,6 +1059,35 @@ module Tapioca
           )
         end
 
+        sig { void }
+        def create_where_relation_method
+          relation_methods_module.create_method("where") do |method|
+            method.add_rest_param("args")
+
+            method.add_sig do |sig|
+              sig.return_type = RelationWhereChainClassName
+            end
+
+            method.add_sig do |sig|
+              sig.add_param("args", "T.untyped")
+              sig.return_type = RelationClassName
+            end
+          end
+
+          association_relation_methods_module.create_method("where") do |method|
+            method.add_rest_param("args")
+
+            method.add_sig do |sig|
+              sig.return_type = AssociationRelationWhereChainClassName
+            end
+
+            method.add_sig do |sig|
+              sig.add_param("args", "T.untyped")
+              sig.return_type = AssociationRelationClassName
+            end
+          end
+        end
+
         sig do
           params(
             name: T.any(Symbol, String),

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

@@ -147,7 +147,17 @@ module Tapioca
           return "T.untyped" if type.nil?
 
           sorbet_type = if type.respond_to?(:sorbet_type)
+            line, file = type.method(:sorbet_type).source_location
+
+            $stderr.puts <<~MESSAGE
+              WARNING: `#sorbet_type` is deprecated. Please rename your method to `#__tapioca_type`."
+
+              Defined on line #{line} of #{file}
+            MESSAGE
+
             type.sorbet_type
+          elsif type.respond_to?(:__tapioca_type)
+            type.__tapioca_type
           elsif type == ::JsonApiClient::Schema::Types::Integer
             "::Integer"
           elsif type == ::JsonApiClient::Schema::Types::String

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

@@ -14,7 +14,8 @@ module Tapioca
           def type_for(type_value)
             return "T.untyped" if Runtime::GenericTypeRegistry.generic_type_instance?(type_value)
 
-            type = lookup_return_type_of_method(type_value, :deserialize) ||
+            type = lookup_tapioca_type(type_value) ||
+              lookup_return_type_of_method(type_value, :deserialize) ||
               lookup_return_type_of_method(type_value, :cast) ||
               lookup_return_type_of_method(type_value, :cast_value) ||
               lookup_arg_type_of_method(type_value, :serialize) ||
@@ -22,6 +23,11 @@ module Tapioca
             type.to_s
           end
 
+          sig { params(type_value: T.untyped).returns(T::Boolean) }
+          def assume_nilable?(type_value)
+            !type_value.respond_to?(:__tapioca_type)
+          end
+
           private
 
           MEANINGLESS_TYPES = T.let(
@@ -39,6 +45,11 @@ module Tapioca
             !MEANINGLESS_TYPES.include?(type)
           end
 
+          sig { params(obj: T.untyped).returns(T.nilable(T::Types::Base)) }
+          def lookup_tapioca_type(obj)
+            T::Utils.coerce(obj.__tapioca_type) if obj.respond_to?(:__tapioca_type)
+          end
+
           sig { params(obj: T.untyped, method: Symbol).returns(T.nilable(T::Types::Base)) }
           def lookup_return_type_of_method(obj, method)
             return_type = lookup_signature_of_method(obj, method)&.return_type

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

@@ -211,6 +211,11 @@ module Tapioca
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range === type
                }
             "T::Range[#{type_for_activerecord_value(column_type.subtype, column_nullability:)}]"
+          when ->(type) {
+                 defined?(ActiveRecord::Locking::LockingType) &&
+                   ActiveRecord::Locking::LockingType === type
+               }
+            as_non_nilable_if_persisted_and_not_nullable("::Integer", column_nullability:)
           else
             as_non_nilable_if_persisted_and_not_nullable(
               ActiveModelTypeHelper.type_for(column_type),

data/lib/tapioca/dsl/pipeline.rb

@@ -34,6 +34,7 @@ module Tapioca
           skipped_constants: T::Array[Module],
           number_of_workers: T.nilable(Integer),
           compiler_options: T::Hash[String, T.untyped],
+          lsp_addon: T::Boolean,
         ).void
       end
       def initialize(
@@ -44,7 +45,8 @@ module Tapioca
         error_handler: $stderr.method(:puts).to_proc,
         skipped_constants: [],
         number_of_workers: nil,
-        compiler_options: {}
+        compiler_options: {},
+        lsp_addon: false
       )
         @active_compilers = T.let(
           gather_active_compilers(requested_compilers, excluded_compilers),
@@ -56,6 +58,7 @@ module Tapioca
         @skipped_constants = skipped_constants
         @number_of_workers = number_of_workers
         @compiler_options = compiler_options
+        @lsp_addon = lsp_addon
         @errors = T.let([], T::Array[String])
       end
 
@@ -177,7 +180,7 @@ module Tapioca
         # Find the constants that have been reloaded
         reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
 
-        unless reloaded_constants.empty?
+        unless reloaded_constants.empty? || @lsp_addon
           reloaded_constant_names = reloaded_constants.map { |name| "`#{name}`" }.join(", ")
 
           $stderr.puts("WARNING: Multiple constants with the same name: #{reloaded_constant_names}")
@@ -222,9 +225,14 @@ module Tapioca
 
       sig { void }
       def abort_if_pending_migrations!
+        # When running within the add-on, we cannot invoke the abort if pending migrations task because that will exit
+        # the process and crash the Rails runtime server. Instead, the Rails add-on checks for pending migrations and
+        # warns the user, so that they are aware they need to migrate their database
+        return if @lsp_addon
         return unless defined?(::Rake)
 
         Rails.application.load_tasks
+
         if Rake::Task.task_defined?("db:abort_if_pending_migrations")
           Rake::Task["db:abort_if_pending_migrations"].invoke
         end

data/lib/tapioca/gemfile.rb

@@ -66,15 +66,24 @@ module Tapioca
 
     sig { returns([T::Enumerable[Spec], T::Array[String]]) }
     def materialize_deps
-      deps = definition.locked_gems.dependencies.values
-      materialized_dependencies = definition.resolve.materialize(deps)
-      missing_spec_names = materialized_dependencies.missing_specs.map(&:name).to_set
-      missing_specs = materialized_dependencies.missing_specs.map do |spec|
-        "#{spec.name} (#{spec.version})"
-      end
-      materialized_dependencies = materialized_dependencies.to_a.reject do |spec|
-        missing_spec_names.include?(spec.name)
+      deps = definition.locked_gems.dependencies.except(*@excluded_gems).values
+      resolve = definition.resolve
+      materialized_dependencies = resolve.materialize(deps)
+
+      if Bundler::VERSION >= "2.6.0"
+        missing_specs = resolve.missing_specs.map do |spec|
+          "#{spec.name} (#{spec.version})"
+        end
+      else
+        missing_spec_names = materialized_dependencies.missing_specs.map(&:name).to_set
+        missing_specs = materialized_dependencies.missing_specs.map do |spec|
+          "#{spec.name} (#{spec.version})"
+        end
+        materialized_dependencies = materialized_dependencies.to_a.reject do |spec|
+          missing_spec_names.include?(spec.name)
+        end
       end
+
       [materialized_dependencies, missing_specs]
     end
 

data/lib/tapioca/helpers/git_attributes.rb

@@ -28,7 +28,8 @@ class GitAttributes
       # exist, we just return.
       return unless path.exist?
 
-      File.write(path.join(".gitattributes"), content)
+      git_attributes_path = path.join(".gitattributes")
+      File.write(git_attributes_path, content) unless git_attributes_path.exist?
     end
   end
 end

data/lib/tapioca/helpers/source_uri.rb

@@ -25,9 +25,6 @@ module URI
     # have the uri gem in their own bundle and thus not use a compatible version.
     PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
 
-    alias_method(:gem_name, :host)
-    alias_method(:line_number, :fragment)
-
     sig { returns(T.nilable(String)) }
     attr_reader :gem_version
 
@@ -54,6 +51,16 @@ module URI
       end
     end
 
+    sig { returns(T.nilable(String)) }
+    def gem_name
+      host
+    end
+
+    sig { returns(T.nilable(String)) }
+    def line_number
+      fragment
+    end
+
     sig { params(v: T.nilable(String)).void }
     def set_path(v) # rubocop:disable Naming/AccessorMethodName
       return if v.nil?

data/lib/tapioca/loaders/dsl.rb

@@ -10,16 +10,32 @@ module Tapioca
         extend T::Sig
 
         sig do
-          params(tapioca_path: String, eager_load: T::Boolean, app_root: String, halt_upon_load_error: T::Boolean).void
+          params(
+            tapioca_path: String,
+            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)
+        def load_application(
+          tapioca_path:,
+          eager_load: true,
+          app_root: ".",
+          halt_upon_load_error: true,
+          lsp_addon: false
+        )
           loader = new(
             tapioca_path: tapioca_path,
             eager_load: eager_load,
             app_root: app_root,
             halt_upon_load_error: halt_upon_load_error,
           )
-          loader.load
+          if lsp_addon
+            loader.load_dsl_extensions_and_compilers
+          else
+            loader.load
+          end
         end
       end
 
@@ -30,6 +46,12 @@ module Tapioca
         load_dsl_compilers
       end
 
+      sig { void }
+      def load_dsl_extensions_and_compilers
+        load_dsl_extensions
+        load_dsl_compilers
+      end
+
       protected
 
       sig do
@@ -63,7 +85,7 @@ module Tapioca
       def load_dsl_compilers
         say("Loading DSL compiler classes... ")
 
-        # Load all built-in compilers
+        # Load all built-in compilers before any custom compilers
         Dir.glob("#{Tapioca::LIB_ROOT_DIR}/tapioca/dsl/compilers/*.rb").each do |compiler|
           require File.expand_path(compiler)
         end

data/lib/tapioca/static/symbol_loader.rb

@@ -51,6 +51,8 @@ module Tapioca
 
         sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
         def symbols_from_paths(paths)
+          return Set.new if paths.empty?
+
           output = Tempfile.create("sorbet") do |file|
             file.write(Array(paths).join("\n"))
             file.flush

data/lib/tapioca/version.rb

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

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.16.4
+  version: 0.16.6
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
 - Alan Wu
 - Alexandre Terrasa
 - Peter Zhu
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2025-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -125,7 +124,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - ruby@shopify.com
 executables:
@@ -136,6 +134,8 @@ files:
 - LICENSE.txt
 - README.md
 - exe/tapioca
+- lib/ruby_lsp/tapioca/addon.rb
+- lib/ruby_lsp/tapioca/server_addon.rb
 - lib/tapioca.rb
 - lib/tapioca/bundler_ext/auto_require_hook.rb
 - lib/tapioca/cli.rb
@@ -269,7 +269,6 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -284,8 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard
   library