brew style --fix

Library/Homebrew/cli/args.rbi

@@ -321,7 +321,7 @@ module Homebrew
       sig { returns(T.nilable(String)) }
       def screen_saverdir; end
 
-      sig { returns(T::Array[String])}
+      sig { returns(T::Array[String]) }
       def repositories; end
 
       sig { returns(T.nilable(String)) }

Library/Homebrew/dependencies.rbi

@@ -4,8 +4,8 @@ class Dependencies < SimpleDelegator
   include Kernel
   # This is a workaround to enable `alias eql? ==`
   # @see https://github.com/sorbet/sorbet/issues/2378#issuecomment-569474238
-  sig { params(arg0: BasicObject).returns(T::Boolean) }
+  sig { params(other: BasicObject).returns(T::Boolean) }
-  def ==(arg0); end
+  def ==(other); end
 end
 
 class Requirements < SimpleDelegator

Library/Homebrew/download_strategy.rbi

@@ -4,15 +4,20 @@ module AbstractDownloadStrategy::Pourable
   requires_ancestor { AbstractDownloadStrategy }
 end
 
+# This is a third-party implementation
+# rubocop:disable Lint/StructNewOverride
 class Mechanize::HTTP
   ContentDisposition = Struct.new :type, :filename, :creation_date,
-    :modification_date, :read_date, :size, :parameters
+                                  :modification_date, :read_date, :size, :parameters
 end
+# rubocop:enable Lint/StructNewOverride
 
+# rubocop:disable Style/OptionalBooleanParameter
 class Mechanize::HTTP::ContentDispositionParser
   sig {
     params(content_disposition: String, header: T::Boolean)
-    .returns(T.nilable(Mechanize::HTTP::ContentDisposition))
+      .returns(T.nilable(Mechanize::HTTP::ContentDisposition))
   }
   def parse(content_disposition, header = false); end
 end
+# rubocop:enable Style/OptionalBooleanParameter

Library/Homebrew/extend/hash/deep_merge.rbi

@@ -2,19 +2,19 @@
 # frozen_string_literal: true
 
 class Hash
-  sig do
+  sig {
     type_parameters(:k2).params(
       other_hash: T::Hash[T.type_parameter(:k2), T.untyped],
-      block: T.nilable(T.proc.params(k: T.untyped, v1: T.untyped, v2: T.untyped).returns(T.untyped))
+      block:      T.nilable(T.proc.params(k: T.untyped, v1: T.untyped, v2: T.untyped).returns(T.untyped)),
     ).returns(T::Hash[T.any(Hash::K, T.type_parameter(:k2)), T.untyped])
-  end
+  }
   def deep_merge(other_hash, &block); end
 
-  sig do
+  sig {
     type_parameters(:k2).params(
       other_hash: T::Hash[T.type_parameter(:k2), T.untyped],
-      block: T.nilable(T.proc.params(k: T.untyped, v1: T.untyped, v2: T.untyped).returns(T.untyped))
+      block:      T.nilable(T.proc.params(k: T.untyped, v1: T.untyped, v2: T.untyped).returns(T.untyped)),
     ).returns(T::Hash[T.any(Hash::K, T.type_parameter(:k2)), T.untyped])
-  end
+  }
   def deep_merge!(other_hash, &block); end
 end

Library/Homebrew/extend/hash/deep_transform_values.rbi

@@ -3,14 +3,14 @@
 class Hash
   sig {
     type_parameters(:out).params(
-      block: T.proc.params(o: Hash::V).returns(T.type_parameter(:out))
+      block: T.proc.params(o: Hash::V).returns(T.type_parameter(:out)),
     ).returns(T::Hash[Hash::K, T.type_parameter(:out)])
   }
   def deep_transform_values(&block); end
 
   sig {
     type_parameters(:out).params(
-      block: T.proc.params(o: Hash::V).returns(T.type_parameter(:out))
+      block: T.proc.params(o: Hash::V).returns(T.type_parameter(:out)),
     ).returns(T::Hash[Hash::K, T.type_parameter(:out)])
   }
   def deep_transform_values!(&block); end

Library/Homebrew/extend/hash/keys.rbi

@@ -4,14 +4,14 @@
 class Hash
   sig {
     type_parameters(:out).params(
-      block: T.proc.params(o: K).returns(T.type_parameter(:out))
+      block: T.proc.params(o: K).returns(T.type_parameter(:out)),
     ).returns(T::Hash[T.type_parameter(:out), V])
   }
   def deep_transform_keys(&block); end
 
   sig {
     type_parameters(:out).params(
-      block: T.proc.params(o: K).returns(T.type_parameter(:out))
+      block: T.proc.params(o: K).returns(T.type_parameter(:out)),
     ).returns(T::Hash[T.type_parameter(:out), V])
   }
   def deep_transform_keys!(&block); end

Library/Homebrew/pkg_version.rbi

@@ -3,6 +3,6 @@
 class PkgVersion
   # This is a workaround to enable `alias eql? ==`
   # @see https://github.com/sorbet/sorbet/issues/2378#issuecomment-569474238
-  sig { params(arg0: BasicObject).returns(T::Boolean) }
+  sig { params(other: BasicObject).returns(T::Boolean) }
-  def ==(arg0); end
+  def ==(other); end
 end

Library/Homebrew/sorbet/rbi/parlour.rbi

@@ -1,4 +1,5 @@
 # typed: strict
+
 class PATH
   sig { params(args: T.untyped, options: T.untyped, block: T.untyped).returns(T.untyped) }
   def each(*args, **options, &block); end

Library/Homebrew/sorbet/rbi/upstream.rbi

@@ -7,6 +7,7 @@
 class Array
   include JSON::Ext::Generator::GeneratorMethods::Array
 end
+
 class Hash
   include JSON::Ext::Generator::GeneratorMethods::Hash
 end
@@ -31,108 +32,108 @@ end
 
 # https://github.com/sorbet/sorbet/pull/7678
 class String
-  sig do
+  sig {
     params(
-        arg0: Integer,
+      arg0: Integer,
-        arg1: Integer,
+      arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: T.any(T::Range[Integer], Regexp),
+      arg0: T.any(T::Range[Integer], Regexp),
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: Regexp,
+      arg0: Regexp,
-        arg1: Integer,
+      arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-   sig do
+  sig {
-     params(
-         arg0: Regexp,
-         arg1: T.any(String, Symbol),
-     )
-     .returns(T.nilable(String))
-   end
-  sig do
     params(
-        arg0: String,
+      arg0: Regexp,
+      arg1: T.any(String, Symbol),
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  def [](arg0, arg1=T.unsafe(nil)); end
+  sig {
+    params(
+      arg0: String,
+    )
+      .returns(T.nilable(String))
+  }
+  def [](arg0, arg1 = T.unsafe(nil)); end
 
-  sig do
+  sig {
-     params(
-         arg0: Integer,
-         arg1: Integer,
-     )
-     .returns(T.nilable(String))
-  end
-  sig do
     params(
-        arg0: T.any(T::Range[Integer], Regexp),
+      arg0: Integer,
+      arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: Regexp,
+      arg0: T.any(T::Range[Integer], Regexp),
-        arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-   sig do
+  sig {
-     params(
-         arg0: Regexp,
-         arg1: T.any(String, Symbol),
-     )
-     .returns(T.nilable(String))
-   end
-  sig do
     params(
-        arg0: String,
+      arg0: Regexp,
+      arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  def slice!(arg0, arg1=T.unsafe(nil)); end
+  sig {
+    params(
+      arg0: Regexp,
+      arg1: T.any(String, Symbol),
+    )
+      .returns(T.nilable(String))
+  }
+  sig {
+    params(
+      arg0: String,
+    )
+      .returns(T.nilable(String))
+  }
+  def slice!(arg0, arg1 = T.unsafe(nil)); end
 
-  sig do
+  sig {
     params(
-        arg0: Integer,
+      arg0: Integer,
-        arg1: Integer,
+      arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: T.any(T::Range[Integer], Regexp),
+      arg0: T.any(T::Range[Integer], Regexp),
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: Regexp,
+      arg0: Regexp,
-        arg1: Integer,
+      arg1: Integer,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: Regexp,
+      arg0: Regexp,
-        arg1: T.any(String, Symbol),
+      arg1: T.any(String, Symbol),
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  sig do
+  sig {
     params(
-        arg0: String,
+      arg0: String,
     )
-    .returns(T.nilable(String))
+      .returns(T.nilable(String))
-  end
+  }
-  def slice(arg0, arg1=T.unsafe(nil)); end
+  def slice(arg0, arg1 = T.unsafe(nil)); end
 end