tapioca 0.16.10 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b1ddf8615a19929d81d7662c300a28ee8d49d08d7ba984fdaa7644bf70d5dfb
-  data.tar.gz: 4f2a79db13ce4a0e7614178d14423f5bd0fded127a6c5b6d0503bf7e2d73df7b
+  metadata.gz: aae584802448b64d85f5d3da609325b145bc698816d6564a09a45696aa338901
+  data.tar.gz: d2673e9edcb91ba6fd7253a7bbd1b83505a4f2bb79ecde5159327f8775187d33
 SHA512:
-  metadata.gz: a03a8d4866b5faf46af5cea289d4d7087540d58ee5b4eb759cb30cc23c540cc037c03bdd937cdf73e3f955407b2a47865600297fafe6b495e786e64b99f38942
-  data.tar.gz: 3a5bf689b47f198577480420b9ea0c1294a6c2170df0f5ba9a6e170a8f60b3d2de73827053f4b33002f1a6ae9f2501a73b70590c250c8306b86d52b244aa7f36
+  metadata.gz: c1bbcb3975a85609b72642c849489743d4ba784c6ac5c5d1fe5f698dbadec683d141c8e8b42e63bd537f5c5770571d9446a05d865d381619b21ffe16acea8a89
+  data.tar.gz: dc09f320a84af9eac62d79219cfa282c630b2b01b72ddf33971b7e235757a9e96249f7c98c34ba13679c2d1e2a7148bf6609418fb03bbd904b991a665dfe76e1

data/lib/ruby_lsp/tapioca/addon.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.24")
+RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.25")
 
 begin
   # The Tapioca add-on depends on the Rails add-on to add a runtime component to the runtime server. We can allow the
@@ -20,19 +20,20 @@ module RubyLsp
     class Addon < ::RubyLsp::Addon
       extend T::Sig
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
-        @global_state = T.let(nil, T.nilable(RubyLsp::GlobalState))
-        @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))
+        @global_state = nil #: RubyLsp::GlobalState?
+        @rails_runner_client = Rails::NullClient.new #: RubyLsp::Rails::RunnerClient
+        @index = nil #: RubyIndexer::Index?
+        @file_checksums = {} #: Hash[String, String]
+        @lockfile_diff = nil #: String?
+        @outgoing_queue = nil #: Thread::Queue?
       end
 
-      sig { override.params(global_state: RubyLsp::GlobalState, outgoing_queue: Thread::Queue).void }
+      # @override
+      #: (RubyLsp::GlobalState global_state, Thread::Queue outgoing_queue) -> void
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         return unless @global_state.enabled_feature?(:tapiocaAddon)
@@ -67,28 +68,31 @@ module RubyLsp
         end
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def deactivate
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def name
         "Tapioca"
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def version
-        "0.1.2"
+        "0.1.3"
       end
 
-      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      #: (Array[{uri: String, type: Integer}] changes) -> void
       def workspace_did_change_watched_files(changes)
         return unless @global_state&.enabled_feature?(:tapiocaAddon)
         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)
+        has_route_change = false #: bool
+        has_fixtures_change = false #: bool
+        needs_compiler_reload = false #: bool
 
         constants = changes.flat_map do |change|
           path = URI(change[:uri]).to_standardized_path
@@ -153,7 +157,7 @@ module RubyLsp
 
       private
 
-      sig { params(feature_name: String).void }
+      #: (String feature_name) -> void
       def send_usage_telemetry(feature_name)
         return unless @outgoing_queue && @global_state
 
@@ -172,7 +176,7 @@ module RubyLsp
         })
       end
 
-      sig { params(change: T::Hash[Symbol, T.untyped], path: String).returns(T::Boolean) }
+      #: (Hash[Symbol, untyped] change, String path) -> bool
       def file_updated?(change, path)
         case change[:type]
         when Constant::FileChangeType::CREATED
@@ -201,7 +205,7 @@ module RubyLsp
         false
       end
 
-      sig { void }
+      #: -> void
       def run_gem_rbi_check
         gem_rbi_check = RunGemRbiCheck.new(T.must(@global_state).workspace_path)
         gem_rbi_check.run

data/lib/ruby_lsp/tapioca/run_gem_rbi_check.rb

@@ -13,15 +13,15 @@ module RubyLsp
       attr_reader :stderr
       attr_reader :status
 
-      sig { params(project_path: String).void }
+      #: (String project_path) -> 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))
+        @stdout = "" #: String
+        @stderr = "" #: String
+        @status = nil #: Process::Status?
       end
 
-      sig { void }
+      #: -> void
       def run
         return log_message("Not a git repository") unless git_repo?
 
@@ -36,35 +36,35 @@ module RubyLsp
 
       attr_reader :project_path
 
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def git_repo?
         _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: project_path)
         status.success?
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def lockfile_changed?
         !lockfile_diff.empty?
       end
 
-      sig { returns(Pathname) }
+      #: -> Pathname
       def lockfile
-        @lockfile ||= T.let(Pathname(project_path).join("Gemfile.lock"), T.nilable(Pathname))
+        @lockfile ||= Pathname(project_path).join("Gemfile.lock") #: Pathname?
       end
 
-      sig { returns(String) }
+      #: -> String
       def lockfile_diff
-        @lockfile_diff ||= T.let(read_lockfile_diff, T.nilable(String))
+        @lockfile_diff ||= read_lockfile_diff #: String?
       end
 
-      sig { returns(String) }
+      #: -> String
       def read_lockfile_diff
         return "" unless lockfile.exist?
 
         execute_in_project_path("git", "diff", lockfile.to_s).strip
       end
 
-      sig { void }
+      #: -> void
       def generate_gem_rbis
         parser = Tapioca::LockfileDiffParser.new(@lockfile_diff)
         removed_gems = parser.removed_gems
@@ -78,7 +78,7 @@ module RubyLsp
         end
       end
 
-      sig { params(gems: T::Array[String]).void }
+      #: (Array[String] gems) -> void
       def execute_tapioca_gem_command(gems)
         Bundler.with_unbundled_env do
           stdout, stderr, status = T.unsafe(Open3).capture3(
@@ -97,7 +97,7 @@ module RubyLsp
         end
       end
 
-      sig { params(gems: T::Array[String]).void }
+      #: (Array[String] gems) -> void
       def remove_rbis(gems)
         files = Dir.glob(
           "sorbet/rbi/gems/{#{gems.join(",")}}@*.rbi",
@@ -106,7 +106,7 @@ module RubyLsp
         delete_files(files, "Removed RBIs for")
       end
 
-      sig { void }
+      #: -> void
       def cleanup_orphaned_rbis
         untracked_files = git_ls_gem_rbis("--others", "--exclude-standard")
         deleted_files = git_ls_gem_rbis("--deleted")
@@ -115,7 +115,7 @@ module RubyLsp
         restore_files(deleted_files, "Restored deleted RBIs")
       end
 
-      sig { params(flags: T.untyped).returns(T::Array[String]) }
+      #: (*untyped flags) -> Array[String]
       def git_ls_gem_rbis(*flags)
         flags = T.unsafe(["git", "ls-files", *flags, "sorbet/rbi/gems/"])
 
@@ -124,20 +124,20 @@ module RubyLsp
           .map(&:strip)
       end
 
-      sig { params(files: T::Array[String], message: String).void }
+      #: (Array[String] files, String message) -> 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 }
+      #: (Array[String] files, String message) -> 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 }
+      #: (String message) -> void
       def log_message(message)
         @stdout += "#{message}\n"
       end

data/lib/tapioca/bundler_ext/auto_require_hook.rb

@@ -12,13 +12,13 @@ module Tapioca
 
       requires_ancestor { ::Bundler::Dependency }
 
-      @exclude = T.let([], T::Array[String])
-      @enabled = T.let(false, T::Boolean)
+      @exclude = [] #: Array[String]
+      @enabled = false #: bool
 
       class << self
         extend T::Sig
 
-        sig { params(name: T.untyped).returns(T::Boolean) }
+        #: (untyped name) -> bool
         def excluded?(name)
           @exclude.include?(name)
         end
@@ -27,12 +27,7 @@ module Tapioca
           @enabled
         end
 
-        sig do
-          type_parameters(:Result).params(
-            exclude: T::Array[String],
-            blk: T.proc.returns(T.type_parameter(:Result)),
-          ).returns(T.type_parameter(:Result))
-        end
+        #: [Result] (exclude: Array[String]) { -> Result } -> Result
         def override_require_false(exclude:, &blk)
           @enabled = true
           @exclude = exclude
@@ -42,7 +37,7 @@ module Tapioca
         end
       end
 
-      sig { returns(T.untyped).checked(:never) }
+      #: -> untyped
       def autorequire
         value = super
 

data/lib/tapioca/commands/abstract_dsl.rb

@@ -9,28 +9,7 @@ module Tapioca
 
       abstract!
 
-      sig do
-        params(
-          requested_constants: T::Array[String],
-          requested_paths: T::Array[Pathname],
-          outpath: Pathname,
-          only: T::Array[String],
-          exclude: T::Array[String],
-          file_header: T::Boolean,
-          tapioca_path: String,
-          skip_constant: T::Array[String],
-          quiet: T::Boolean,
-          verbose: T::Boolean,
-          number_of_workers: T.nilable(Integer),
-          auto_strictness: T::Boolean,
-          gem_dir: String,
-          rbi_formatter: RBIFormatter,
-          app_root: String,
-          halt_upon_load_error: T::Boolean,
-          compiler_options: T::Hash[String, T.untyped],
-          lsp_addon: T::Boolean,
-        ).void
-      end
+      #: (requested_constants: Array[String], requested_paths: Array[Pathname], outpath: Pathname, only: Array[String], exclude: Array[String], file_header: bool, tapioca_path: String, ?skip_constant: Array[String], ?quiet: bool, ?verbose: bool, ?number_of_workers: Integer?, ?auto_strictness: bool, ?gem_dir: String, ?rbi_formatter: RBIFormatter, ?app_root: String, ?halt_upon_load_error: bool, ?compiler_options: Hash[String, untyped], ?lsp_addon: bool) -> void
       def initialize(
         requested_constants:,
         requested_paths:,
@@ -75,7 +54,7 @@ module Tapioca
 
       private
 
-      sig { params(outpath: Pathname, quiet: T::Boolean).returns(T::Set[Pathname]) }
+      #: (Pathname outpath, quiet: bool) -> Set[Pathname]
       def generate_dsl_rbi_files(outpath, quiet:)
         if @lsp_addon
           pipeline.active_compilers.each(&:reset_state)
@@ -103,20 +82,17 @@ module Tapioca
         files_to_purge
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def all_requested_constants
-        @all_requested_constants ||= T.let(
-          @requested_constants + constants_from_requested_paths,
-          T.nilable(T::Array[String]),
-        )
+        @all_requested_constants ||= @requested_constants + constants_from_requested_paths #: Array[String]?
       end
 
-      sig { returns(Tapioca::Dsl::Pipeline) }
+      #: -> Tapioca::Dsl::Pipeline
       def pipeline
-        @pipeline ||= T.let(create_pipeline, T.nilable(Tapioca::Dsl::Pipeline))
+        @pipeline ||= create_pipeline #: Tapioca::Dsl::Pipeline?
       end
 
-      sig { void }
+      #: -> void
       def load_application
         # Loaded ahead of time when using the add-on to avoid reloading multiple times
         return if @lsp_addon
@@ -129,17 +105,24 @@ module Tapioca
         )
       end
 
-      sig { returns(Tapioca::Dsl::Pipeline) }
+      #: -> Tapioca::Dsl::Pipeline
       def create_pipeline
+        error_handler = if @lsp_addon
+          ->(error) {
+            say(error)
+          }
+        else
+          ->(error) {
+            say_error(error, :bold, :red)
+          }
+        end
         Tapioca::Dsl::Pipeline.new(
           requested_constants:
             constantize(@requested_constants) + constantize(constants_from_requested_paths, ignore_missing: true),
           requested_paths: @requested_paths,
           requested_compilers: constantize_compilers(@only),
           excluded_compilers: constantize_compilers(@exclude),
-          error_handler: ->(error) {
-            say_error(error, :bold, :red)
-          },
+          error_handler: error_handler,
           skipped_constants: constantize(@skip_constant, ignore_missing: true),
           number_of_workers: @number_of_workers,
           compiler_options: @compiler_options,
@@ -147,7 +130,7 @@ module Tapioca
         )
       end
 
-      sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
+      #: (Array[String] requested_constants, ?path: Pathname) -> Set[Pathname]
       def existing_rbi_filenames(requested_constants, path: @outpath)
         filenames = if requested_constants.empty?
           Pathname.glob(path / "**/*.rbi")
@@ -161,7 +144,7 @@ module Tapioca
         filenames.to_set
       end
 
-      sig { params(constant_names: T::Array[String], ignore_missing: T::Boolean).returns(T::Array[Module]) }
+      #: (Array[String] constant_names, ?ignore_missing: bool) -> Array[Module]
       def constantize(constant_names, ignore_missing: false)
         constant_map = constant_names.to_h do |name|
           [name, Object.const_get(name)]
@@ -186,7 +169,7 @@ module Tapioca
           .grep(Module)
       end
 
-      sig { params(compiler_names: T::Array[String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+      #: (Array[String] compiler_names) -> Array[singleton(Tapioca::Dsl::Compiler)]
       def constantize_compilers(compiler_names)
         compiler_map = compiler_names.to_h do |name|
           [name, resolve(name)]
@@ -206,7 +189,7 @@ module Tapioca
         T.cast(compiler_map.values, T::Array[T.class_of(Tapioca::Dsl::Compiler)])
       end
 
-      sig { params(name: String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
+      #: (String name) -> singleton(Tapioca::Dsl::Compiler)?
       def resolve(name)
         # Try to find built-in tapioca compiler first, then globally defined compiler.
         potentials = Tapioca::Dsl::Compilers::NAMESPACES.map do |namespace|
@@ -219,14 +202,7 @@ module Tapioca
         potentials.compact.first
       end
 
-      sig do
-        params(
-          constant_name: String,
-          rbi: RBI::File,
-          outpath: Pathname,
-          quiet: T::Boolean,
-        ).returns(T.nilable(Pathname))
-      end
+      #: (String constant_name, RBI::File rbi, ?outpath: Pathname, ?quiet: bool) -> Pathname?
       def compile_dsl_rbi(constant_name, rbi, outpath: @outpath, quiet: false)
         return if rbi.empty?
 
@@ -244,7 +220,7 @@ module Tapioca
         filename
       end
 
-      sig { params(dir: Pathname).void }
+      #: (Pathname dir) -> void
       def perform_dsl_verification(dir)
         diff = verify_dsl_rbi(tmp_dir: dir)
 
@@ -253,7 +229,7 @@ module Tapioca
         FileUtils.remove_entry(dir)
       end
 
-      sig { params(files: T::Set[Pathname]).void }
+      #: (Set[Pathname] files) -> void
       def purge_stale_dsl_rbi_files(files)
         if files.any?
           say("Removing stale RBI files...")
@@ -265,12 +241,12 @@ module Tapioca
         end
       end
 
-      sig { params(constant_name: String).returns(Pathname) }
+      #: (String constant_name) -> Pathname
       def dsl_rbi_filename(constant_name)
         @outpath / "#{underscore(constant_name)}.rbi"
       end
 
-      sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+      #: (tmp_dir: Pathname) -> Hash[String, Symbol]
       def verify_dsl_rbi(tmp_dir:)
         diff = {}
 
@@ -302,7 +278,7 @@ module Tapioca
         diff
       end
 
-      sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+      #: (Symbol cause, Array[String] files) -> String
       def build_error_for_files(cause, files)
         filenames = files.map do |file|
           @outpath / file
@@ -311,7 +287,7 @@ module Tapioca
         "  File(s) #{cause}:\n  - #{filenames}"
       end
 
-      sig { params(diff: T::Hash[String, Symbol], command: Symbol).void }
+      #: (Hash[String, Symbol] diff, Symbol command) -> void
       def report_diff_and_exit_if_out_of_date(diff, command)
         if diff.empty?
           say("Nothing to do, all RBIs are up-to-date.")
@@ -333,14 +309,14 @@ module Tapioca
         end
       end
 
-      sig { params(path: Pathname).returns(T::Array[Pathname]) }
+      #: (Pathname path) -> Array[Pathname]
       def rbi_files_in(path)
         Pathname.glob(path / "**/*.rbi").map do |file|
           file.relative_path_from(path)
         end.sort
       end
 
-      sig { params(class_name: String).returns(String) }
+      #: (String class_name) -> String
       def underscore(class_name)
         return class_name unless /[A-Z-]|::/.match?(class_name)
 
@@ -352,22 +328,20 @@ module Tapioca
         word
       end
 
-      sig { params(constant: String).returns(String) }
+      #: (String constant) -> String
       def rbi_filename_for(constant)
         underscore(constant) + ".rbi"
       end
 
-      sig { params(constant: String).returns(String) }
+      #: (String constant) -> String
       def generate_command_for(constant)
         default_command(:dsl, constant)
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def constants_from_requested_paths
-        @constants_from_requested_paths ||= T.let(
-          Static::SymbolLoader.symbols_from_paths(@requested_paths).to_a,
-          T.nilable(T::Array[String]),
-        )
+        @constants_from_requested_paths ||=
+          Static::SymbolLoader.symbols_from_paths(@requested_paths).to_a #: Array[String]?
       end
     end
   end