tests: Prefer let(:klass) { Foo } over described_class

- The "explicit" setting on the `RSpec/DescribedClass` cop is still
  enabled, because `described_class` is bad for Sorbet typing, but
  instead of applying its autocorrections to specify the full class name
  everywhere that `described_class` was used, use
  `let(:klass) { Foo }` so that the repetition per-test isn't massive in
  tests that use it a lot (say, >5 times).

- Changes made with Copilot CLI, agent mode, Claude Opus 4.7.

Author: issyl0

Library/Homebrew/test/PATH_spec.rb

@@ -4,31 +4,34 @@
 require "PATH"
 
 RSpec.describe PATH do
+  sig { returns(T.class_of(PATH)) }
+  let(:klass) { PATH }
+
   describe "#initialize" do
     it "can take multiple arguments" do
-      expect(described_class.new("/path1", "/path2")).to eq("/path1:/path2")
+      expect(klass.new("/path1", "/path2")).to eq("/path1:/path2")
     end
 
     it "can parse a mix of arrays and arguments" do
-      expect(described_class.new(["/path1", "/path2"], "/path3")).to eq("/path1:/path2:/path3")
+      expect(klass.new(["/path1", "/path2"], "/path3")).to eq("/path1:/path2:/path3")
     end
 
     it "splits an existing PATH" do
-      expect(described_class.new("/path1:/path2")).to eq(["/path1", "/path2"])
+      expect(klass.new("/path1:/path2")).to eq(["/path1", "/path2"])
     end
 
     it "removes duplicates" do
-      expect(described_class.new("/path1", "/path1")).to eq("/path1")
+      expect(klass.new("/path1", "/path1")).to eq("/path1")
     end
   end
 
   describe "#to_ary" do
     it "returns a PATH array" do
-      expect(described_class.new("/path1", "/path2").to_ary).to eq(["/path1", "/path2"])
+      expect(klass.new("/path1", "/path2").to_ary).to eq(["/path1", "/path2"])
     end
 
     it "does not allow mutating the original" do
-      path = described_class.new("/path1", "/path2")
+      path = klass.new("/path1", "/path2")
       path.to_ary << "/path3"
 
       expect(path).not_to include("/path3")
@@ -37,53 +40,53 @@
 
   describe "#to_str" do
     it "returns a PATH string" do
-      expect(described_class.new("/path1", "/path2").to_str).to eq("/path1:/path2")
+      expect(klass.new("/path1", "/path2").to_str).to eq("/path1:/path2")
     end
   end
 
   describe "#prepend" do
     specify(:aggregate_failures) do
-      expect(described_class.new("/path1").prepend("/path2").to_str).to eq("/path2:/path1")
-      expect(described_class.new("/path1").prepend("/path1").to_str).to eq("/path1")
+      expect(klass.new("/path1").prepend("/path2").to_str).to eq("/path2:/path1")
+      expect(klass.new("/path1").prepend("/path1").to_str).to eq("/path1")
     end
   end
 
   describe "#append" do
     specify(:aggregate_failures) do
-      expect(described_class.new("/path1").append("/path2").to_str).to eq("/path1:/path2")
-      expect(described_class.new("/path1").append("/path1").to_str).to eq("/path1")
+      expect(klass.new("/path1").append("/path2").to_str).to eq("/path1:/path2")
+      expect(klass.new("/path1").append("/path1").to_str).to eq("/path1")
     end
   end
 
   describe "#insert" do
     specify(:aggregate_failures) do
-      expect(described_class.new("/path1").insert(0, "/path2").to_str).to eq("/path2:/path1")
-      expect(described_class.new("/path1").insert(0, "/path2", "/path3")).to eq("/path2:/path3:/path1")
+      expect(klass.new("/path1").insert(0, "/path2").to_str).to eq("/path2:/path1")
+      expect(klass.new("/path1").insert(0, "/path2", "/path3")).to eq("/path2:/path3:/path1")
     end
   end
 
   describe "#==" do
     it "always returns false when comparing against something which does not respond to `#to_ary` or `#to_str`" do
-      expect(described_class.new).not_to eq Object.new
+      expect(klass.new).not_to eq Object.new
     end
   end
 
   describe "#include?" do
     it "returns true if a path is included", :aggregate_failures do
-      path = described_class.new("/path1", "/path2")
+      path = klass.new("/path1", "/path2")
       expect(path).to include("/path1")
       expect(path).to include("/path2")
-      expect(described_class.new("/path1", "/path2")).not_to include("/path1:")
+      expect(klass.new("/path1", "/path2")).not_to include("/path1:")
     end
 
     it "returns false if a path is not included" do
-      expect(described_class.new("/path1")).not_to include("/path2")
+      expect(klass.new("/path1")).not_to include("/path2")
     end
   end
 
   describe "#each" do
     it "loops through each path" do
-      enum = described_class.new("/path1", "/path2").each
+      enum = klass.new("/path1", "/path2").each
 
       expect(enum.next).to eq("/path1")
       expect(enum.next).to eq("/path2")
@@ -92,13 +95,13 @@
 
   describe "#select" do
     it "returns an object of the same class instead of an Array" do
-      expect(described_class.new.select { true }).to be_a(described_class)
+      expect(klass.new.select { true }).to be_a(klass)
     end
   end
 
   describe "#reject" do
     it "returns an object of the same class instead of an Array" do
-      expect(described_class.new.reject { true }).to be_a(described_class)
+      expect(klass.new.reject { true }).to be_a(klass)
     end
   end
 
@@ -107,13 +110,15 @@
       allow(File).to receive(:directory?).with("/path1").and_return(true)
       allow(File).to receive(:directory?).with("/path2").and_return(false)
 
-      path = described_class.new("/path1", "/path2")
-      expect(path.existing.to_ary).to eq(["/path1"])
+      path = klass.new("/path1", "/path2")
+      existing = path.existing
+      expect(existing).not_to be_nil
+      expect(existing&.to_ary).to eq(["/path1"])
       expect(path.to_ary).to eq(["/path1", "/path2"])
     end
 
-    it "returns nil instead of an empty #{described_class}" do
-      expect(described_class.new.existing).to be_nil
+    it "returns nil instead of an empty #{PATH}" do
+      expect(klass.new.existing).to be_nil
     end
   end
 end

Library/Homebrew/test/abstract_command_spec.rb

@@ -4,9 +4,11 @@
 require "abstract_command"
 
 RSpec.describe Homebrew::AbstractCommand do
+  let(:klass) { Homebrew::AbstractCommand }
+
   describe "subclasses" do
     before do
-      test_cat = Class.new(described_class) do
+      test_cat = Class.new(klass) do
         cmd_args do
           description "test"
           switch "--foo"
@@ -37,7 +39,7 @@ def run; end
       end
 
       it "can lookup command" do
-        expect(described_class.command("test-cat")).to be(TestCat)
+        expect(klass.command("test-cat")).to be(TestCat)
       end
 
       it "removes -cmd suffix from command name" do
@@ -47,15 +49,15 @@ def run; end
 
       describe "when command name is overridden" do
         before do
-          tac = Class.new(described_class) do
+          tac = Class.new(klass) do
             def self.command_name = "t-a-c"
             def run; end
           end
           stub_const("Tac", tac)
         end
 
         it "can be looked up by command name" do
-          expect(described_class.command("t-a-c")).to be(Tac)
+          expect(klass.command("t-a-c")).to be(Tac)
         end
       end
     end
@@ -67,7 +69,7 @@ def run; end
         Dir[File.join(__dir__, "../#{dir}", "*.rb")].each do |file|
           filename = File.basename(file, ".rb")
           require(file)
-          command = described_class.command(filename)
+          command = klass.command(filename)
           expect(Pathname(File.join(__dir__, "../#{dir}/#{command.command_name}.rb"))).to exist
         end
       end

Library/Homebrew/test/abstract_subcommand_spec.rb

@@ -5,9 +5,11 @@
 require "abstract_subcommand"
 
 RSpec.describe Homebrew::AbstractSubcommand do
+  let(:klass) { Homebrew::AbstractSubcommand }
+
   describe "subclasses" do
     before do
-      subcommand = Class.new(described_class) do
+      subcommand = Class.new(klass) do
         subcommand_args aliases: ["ts"], default: true do
           usage_banner <<~EOS
             `brew test`:
@@ -39,33 +41,33 @@ def run; end
     end
 
     it "finds subcommands nested under a command class" do
-      nested_subcommand = Class.new(described_class) do
+      nested_subcommand = Class.new(klass) do
         subcommand_args { named_args :none }
         def run; end
       end
       stub_const("SubcommandTestCmd::NestedSubcommand", nested_subcommand)
       stub_const("OtherSubcommandTestCmd", Class.new(Homebrew::AbstractCommand))
-      other_subcommand = Class.new(described_class) do
+      other_subcommand = Class.new(klass) do
         subcommand_args { named_args :none }
         def run; end
       end
       stub_const("OtherSubcommandTestCmd::NestedSubcommand", other_subcommand)
 
-      expect(described_class.subcommands_for(SubcommandTestCmd)).to include(nested_subcommand)
-      expect(described_class.subcommands_for(SubcommandTestCmd)).not_to include(other_subcommand)
+      expect(klass.subcommands_for(SubcommandTestCmd)).to include(nested_subcommand)
+      expect(klass.subcommands_for(SubcommandTestCmd)).not_to include(other_subcommand)
     end
 
     it "defines all subcommands nested under a command class" do
-      stub_const("SubcommandTestCmd::FirstSubcommand", Class.new(described_class) do
+      stub_const("SubcommandTestCmd::FirstSubcommand", Class.new(klass) do
         subcommand_args { named_args :none }
         def run; end
       end)
-      stub_const("SubcommandTestCmd::SecondSubcommand", Class.new(described_class) do
+      stub_const("SubcommandTestCmd::SecondSubcommand", Class.new(klass) do
         subcommand_args { named_args :none }
         def run; end
       end)
 
-      abstract_subcommand = described_class
+      abstract_subcommand = klass
       parser = Homebrew::CLI::Parser.new(SubcommandTestCmd) do
         abstract_subcommand.define_all(self, command: SubcommandTestCmd)
       end

Library/Homebrew/test/api/cask/cask_struct_generator_spec.rb

@@ -4,6 +4,8 @@
 require "api"
 
 RSpec.describe Homebrew::API::Cask::CaskStructGenerator do
+  let(:klass) { Homebrew::API::Cask::CaskStructGenerator }
+
   describe ":process_depends_on" do
     let(:depends_on_non_macos) do
       {
@@ -18,13 +20,13 @@
     let(:depends_on_maximum_macos) { { maximum_macos: MacOSRequirement.new([:sequoia], comparator: "<=") } }
 
     specify :aggregate_failures do
-      expect(described_class.process_depends_on(depends_on_non_macos)).to eq({ arch: :intel, formula: ["foo"] })
-      expect(described_class.process_depends_on(depends_on_linux)).to eq({ linux: :any })
-      expect(described_class.process_depends_on(depends_on_macos_equals)).to eq({ macos: [:sequoia] })
-      expect(described_class.process_depends_on(depends_on_macos_greater)).to eq({ macos: :sequoia })
-      expect(described_class.process_depends_on(depends_on_macos_bare)).to eq({ macos: :any })
-      expect(described_class.process_depends_on({ macos: {} })).to eq({ macos: :any })
-      expect(described_class.process_depends_on(depends_on_maximum_macos)).to eq({ maximum_macos: :sequoia })
+      expect(klass.process_depends_on(depends_on_non_macos)).to eq({ arch: :intel, formula: ["foo"] })
+      expect(klass.process_depends_on(depends_on_linux)).to eq({ linux: :any })
+      expect(klass.process_depends_on(depends_on_macos_equals)).to eq({ macos: [:sequoia] })
+      expect(klass.process_depends_on(depends_on_macos_greater)).to eq({ macos: :sequoia })
+      expect(klass.process_depends_on(depends_on_macos_bare)).to eq({ macos: :any })
+      expect(klass.process_depends_on({ macos: {} })).to eq({ macos: :any })
+      expect(klass.process_depends_on(depends_on_maximum_macos)).to eq({ maximum_macos: :sequoia })
     end
   end
 
@@ -41,7 +43,7 @@
       [:bar, ["arg1", "arg2"], { kwarg1: "value1" }, nil],
       [:baz, [], { kwarg1: "value1" }, nil],
     ]
-    output = described_class.process_artifacts(input)
+    output = klass.process_artifacts(input)
     expect(output).to eq expected_output
   end
 
@@ -57,7 +59,7 @@
       using:      :curl,
       bar:        "baz",
     }
-    output = described_class.process_url_specs(input)
+    output = klass.process_url_specs(input)
     expect(output).to eq expected_output
   end
 end

Library/Homebrew/test/api/cask_spec.rb

@@ -4,6 +4,8 @@
 require "api"
 
 RSpec.describe Homebrew::API::Cask do
+  let(:klass) { Homebrew::API::Cask }
+
   let(:cache_dir) { mktmpdir }
 
   before do
@@ -40,7 +42,7 @@ def mock_curl_download(stdout:)
 
     it "returns the expected cask JSON list" do
       mock_curl_download stdout: casks_json
-      casks_output = described_class.all_casks
+      casks_output = klass.all_casks
       expect(casks_output).to eq casks_hash
     end
   end
@@ -68,7 +70,7 @@ def mock_curl_download(stdout:)
         Checksum.new("00ae1ae330365f3d6e4387776f67a9c4b096da3d4546bd0827b5dcafa985234e"),
         any_args,
       ).and_call_original
-      described_class.source_download(cask)
+      klass.source_download(cask)
     end
   end
 end