sorbet: Make more files (that have public APIs defined in them) typed: strict

Library/Homebrew/development_tools.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "version"
@@ -16,7 +16,7 @@ def locate(tool)
  # Don't call tools (cc, make, strip, etc.) directly!
  # Give the name of the binary you look for as a string to this method
  # in order to get the full path back as a Pathname.
- (@locate ||= {}).fetch(tool) do |key|
+ (@locate ||= T.let({}, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]))).fetch(tool) do |key|
  @locate[key] = if File.executable?((path = "/usr/bin/#{tool}"))
  Pathname.new path
  # Homebrew GCCs most frequently; much faster to check this before xcrun
@@ -62,55 +62,57 @@ def default_compiler
  # @api public
  sig { returns(Version) }
  def clang_version
- @clang_version ||= if (path = locate("clang")) &&
- (build_version = `#{path} --version`[/(?:clang|LLVM) version (\d+\.\d(?:\.\d)?)/, 1])
- Version.new build_version
- else
- Version::NULL
- end
+ @clang_version ||= T.let(
+ if (path = locate("clang")) &&
+ (build_version = `#{path} --version`[/(?:clang|LLVM) version (\d+\.\d(?:\.\d)?)/, 1])
+ Version.new(build_version)
+ else
+ Version::NULL
+ end, T.nilable(Version)
+ )
  end
 
  # Get the Clang build version.
  #
  # @api public
  sig { returns(Version) }
  def clang_build_version
- @clang_build_version ||= if (path = locate("clang")) &&
- (build_version = `#{path} --version`[
-%r{clang(-| version [^ ]+ \(tags/RELEASE_)(\d{2,})}, 2])
- Version.new build_version
- else
- Version::NULL
- end
+ @clang_build_version ||= T.let(
+ if (path = locate("clang")) &&
+ (build_version = `#{path} --version`[%r{clang(-| version [^ ]+ \(tags/RELEASE_)(\d{2,})}, 2])
+ Version.new(build_version)
+ else
+ Version::NULL
+ end, T.nilable(Version)
+ )
  end
 
  # Get the LLVM Clang build version.
  #
  # @api public
  sig { returns(Version) }
  def llvm_clang_build_version
- @llvm_clang_build_version ||= begin
+ @llvm_clang_build_version ||= T.let(begin
  path = Formulary.factory("llvm").opt_prefix/"bin/clang"
- if path.executable? &&
- (build_version = `#{path} --version`[/clang version (\d+\.\d\.\d)/, 1])
- Version.new build_version
+ if path.executable? && (build_version = `#{path} --version`[/clang version (\d+\.\d\.\d)/, 1])
+ Version.new(build_version)
  else
  Version::NULL
  end
- end
+ end, T.nilable(Version))
  end
 
  # Get the GCC version.
  #
  # @api internal
  sig { params(cc: String).returns(Version) }
  def gcc_version(cc)
- (@gcc_version ||= {}).fetch(cc) do
+ (@gcc_version ||= T.let({}, T.nilable(T::Hash[String, Version]))).fetch(cc) do
  path = HOMEBREW_PREFIX/"opt/#{CompilerSelector.preferred_gcc}/bin"/cc
  path = locate(cc) unless path.exist?
  version = if path &&
  (build_version = `#{path} --version`[/gcc(?:(?:-\d+(?:\.\d)?)? \(.+\))? (\d+\.\d\.\d)/, 1])
- Version.new build_version
+ Version.new(build_version)
  else
  Version::NULL
  end
@@ -120,8 +122,8 @@ def gcc_version(cc)
 
  sig { void }
  def clear_version_cache
- @clang_version = @clang_build_version = nil
- @gcc_version = {}
+ @clang_version = @clang_build_version = T.let(nil, T.nilable(Version))
+ @gcc_version = T.let({}, T.nilable(T::Hash[String, Version]))
  end
 
  sig { returns(T::Boolean) }

Library/Homebrew/formula_assertions.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -10,15 +10,18 @@ module Assertions
  require "minitest/assertions"
  include ::Minitest::Assertions
 
+ sig { params(assertions: Integer).returns(Integer) }
  attr_writer :assertions
 
+ sig { returns(Integer) }
  def assertions
- @assertions ||= 0
+ @assertions ||= T.let(0, T.nilable(Integer))
  end
 
  # Returns the output of running cmd and asserts the exit status.
  #
  # @api public
+ sig { params(cmd: String, result: Integer).returns(String) }
  def shell_output(cmd, result = 0)
  ohai cmd
  output = `#{cmd}`
@@ -33,6 +36,7 @@ def shell_output(cmd, result = 0)
  # optionally asserts the exit status.
  #
  # @api public
+ sig { params(cmd: String, input: T.nilable(String), result: T.nilable(Integer)).returns(String) }
  def pipe_output(cmd, input = nil, result = nil)
  ohai cmd
  output = IO.popen(cmd, "w+") do |pipe|

Library/Homebrew/unpack_strategy.rb

@@ -1,16 +1,35 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "system_command"
 
 # Module containing all available strategies for unpacking archives.
 module UnpackStrategy
  extend T::Helpers
-
  include SystemCommand::Mixin
+ abstract!
+
+ # FIXME: Enable cop again when https://github.com/sorbet/sorbet/issues/3532 is fixed.
+ # rubocop:disable Style/MutableConstant
+ UnpackStrategyType = T.type_alias { T.all(T::Class[UnpackStrategy], UnpackStrategy::ClassMethods) }
+ # rubocop:enable Style/MutableConstant
+
+ module ClassMethods
+ extend T::Helpers
+ abstract!
+
+ sig { abstract.returns(T::Array[String]) }
+ def extensions; end
 
+ sig { abstract.params(path: Pathname).returns(T::Boolean) }
+ def can_extract?(path); end
+ end
+
+ mixes_in_class_methods(ClassMethods)
+
+ sig { returns(T.nilable(T::Array[UnpackStrategyType])) }
  def self.strategies
- @strategies ||= [
+ @strategies ||= T.let([
  Tar, # Needs to be before Bzip2/Gzip/Xz/Lzma/Zstd.
  Pax,
  Gzip,
@@ -43,10 +62,11 @@ def self.strategies
  Sit,
  Rar,
  Lha,
- ].freeze
+ ].freeze, T.nilable(T::Array[UnpackStrategyType]))
  end
  private_class_method :strategies
 
+ sig { params(type: Symbol).returns(T.nilable(UnpackStrategyType)) }
  def self.from_type(type)
  type = {
  naked: :uncompressed,
@@ -61,23 +81,31 @@ def self.from_type(type)
  end
  end
 
+ sig { params(extension: String).returns(T.nilable(UnpackStrategyType)) }
  def self.from_extension(extension)
- strategies.sort_by { |s| s.extensions.map(&:length).max || 0 }
- .reverse
- .find { |s| s.extensions.any? { |ext| extension.end_with?(ext) } }
+ return unless strategies
+
+ strategies&.sort_by { |s| s.extensions.map(&:length).max || 0 }
+ &.reverse
+ &.find { |s| s.extensions.any? { |ext| extension.end_with?(ext) } }
  end
 
+ sig { params(path: Pathname).returns(T.nilable(UnpackStrategyType)) }
  def self.from_magic(path)
- strategies.find { |s| s.can_extract?(path) }
+ strategies&.find { |s| s.can_extract?(path) }
  end
 
- def self.detect(path, prioritize_extension: false, type: nil, ref_type: nil, ref: nil, merge_xattrs: nil)
+ sig {
+ params(path: Pathname, prioritize_extension: T::Boolean, type: T.nilable(Symbol), ref_type: T.nilable(String),
+ ref: T.nilable(String), merge_xattrs: T::Boolean).returns(T.untyped)
+ }
+ def self.detect(path, prioritize_extension: false, type: nil, ref_type: nil, ref: nil, merge_xattrs: false)
  strategy = from_type(type) if type
 
  if prioritize_extension && path.extname.present?
  strategy ||= from_extension(path.extname)
- strategy ||= strategies.select { |s| s < Directory || s == Fossil }
-  .find { |s| s.can_extract?(path) }
+
+ strategy ||= strategies&.find { |s| (s < Directory || s == Fossil) && s.can_extract?(path) }
  else
  strategy ||= from_magic(path)
  strategy ||= from_extension(path.extname)
@@ -88,24 +116,31 @@ def self.detect(path, prioritize_extension: false, type: nil, ref_type: nil, ref
  strategy.new(path, ref_type:, ref:, merge_xattrs:)
  end
 
- attr_reader :path, :merge_xattrs
+ sig { returns(Pathname) }
+ attr_reader :path
 
- def initialize(path, ref_type: nil, ref: nil, merge_xattrs: nil)
- @path = Pathname(path).expand_path
+ sig { returns(T::Boolean) }
+ attr_reader :merge_xattrs
+
+ sig {
+ params(path: T.any(String, Pathname), ref_type: T.nilable(String), ref: T.nilable(String),
+ merge_xattrs: T::Boolean).void
+ }
+ def initialize(path, ref_type: nil, ref: nil, merge_xattrs: false)
+ @path = T.let(Pathname(path).expand_path, Pathname)
  @ref_type = ref_type
  @ref = ref
  @merge_xattrs = merge_xattrs
  end
 
- abstract!
- sig { abstract.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+ sig { abstract.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
  def extract_to_dir(unpack_dir, basename:, verbose:); end
  private :extract_to_dir
 
  sig {
  params(
  to: T.nilable(Pathname), basename: T.nilable(T.any(String, Pathname)), verbose: T::Boolean,
- ).returns(T.untyped)
+ ).void
  }
  def extract(to: nil, basename: nil, verbose: false)
  basename ||= path.basename
@@ -131,7 +166,10 @@ def extract_nestedly(to: nil, basename: nil, verbose: false, prioritize_extensio
  children = tmp_unpack_dir.children
 
  if children.size == 1 && !children.fetch(0).directory?
- s = UnpackStrategy.detect(children.first, prioritize_extension:)
+ first_child = children.first
+ next if first_child.nil?
+
+ s = UnpackStrategy.detect(first_child, prioritize_extension:)
 
  s.extract_nestedly(to:, verbose:, prioritize_extension:)
 
@@ -149,6 +187,7 @@ def extract_nestedly(to: nil, basename: nil, verbose: false, prioritize_extensio
  end
  end
 
+ sig { returns(T::Array[String]) }
  def dependencies
  []
  end

Library/Homebrew/unpack_strategy/air.rb

@@ -6,7 +6,7 @@ module UnpackStrategy
  class Air
  include UnpackStrategy
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".air"]
  end

Library/Homebrew/unpack_strategy/bzip2.rb

@@ -6,7 +6,7 @@ module UnpackStrategy
  class Bzip2
  include UnpackStrategy
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".bz2"]
  end

Library/Homebrew/unpack_strategy/cab.rb

@@ -6,7 +6,7 @@ module UnpackStrategy
  class Cab
  include UnpackStrategy
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".cab"]
  end

Library/Homebrew/unpack_strategy/compress.rb

@@ -6,7 +6,7 @@
 module UnpackStrategy
  # Strategy for unpacking compress archives.
  class Compress < Tar
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".Z"]
  end

Library/Homebrew/unpack_strategy/directory.rb

@@ -6,7 +6,7 @@ module UnpackStrategy
  class Directory
  include UnpackStrategy
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  []
  end

Library/Homebrew/unpack_strategy/dmg.rb

@@ -121,6 +121,12 @@ def eject(verbose: false)
  end
  end
 
+ sig { override.returns(T::Array[String]) }
+ def self.extensions = []
+
+ sig { override.params(_path: Pathname).returns(T::Boolean) }
+ def self.can_extract?(_path) = false
+
  private
 
  sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
@@ -165,7 +171,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
  end
  private_constant :Mount
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".dmg"]
  end

Library/Homebrew/unpack_strategy/executable.rb

@@ -6,7 +6,7 @@
 module UnpackStrategy
  # Strategy for unpacking executables.
  class Executable < Uncompressed
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".sh", ".bash"]
  end

Library/Homebrew/unpack_strategy/fossil.rb

@@ -9,7 +9,7 @@ class Fossil
  include UnpackStrategy
  extend SystemCommand::Mixin
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  []
  end

Library/Homebrew/unpack_strategy/generic_unar.rb

@@ -6,7 +6,7 @@ module UnpackStrategy
  class GenericUnar
  include UnpackStrategy
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  []
  end

Library/Homebrew/unpack_strategy/gzip.rb

@@ -6,7 +6,7 @@ module UnpackStrategy
  class Gzip
  include UnpackStrategy
 
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".gz"]
  end

Library/Homebrew/unpack_strategy/jar.rb

@@ -6,7 +6,7 @@
 module UnpackStrategy
  # Strategy for unpacking Java archives.
  class Jar < Uncompressed
- sig { returns(T::Array[String]) }
+ sig { override.returns(T::Array[String]) }
  def self.extensions
  [".apk", ".jar"]
  end