Merge pull request #21289 from Homebrew/patch-typed-strict

patch: `typed: strict`

Author: MikeMcQuaid

Library/Homebrew/patch.rb

@@ -1,12 +1,21 @@
-# typed: true # rubocop:todo Sorbet/StrictSigil
+# typed: strict
 # frozen_string_literal: true
 
 require "resource"
 require "erb"
 require "utils/output"
 
+Owner = T.type_alias { T.any(Formula, Resource, SoftwareSpec) }
+
 # Helper module for creating patches.
 module Patch
+  sig {
+    params(
+      strip: T.any(Symbol, String),
+      src:   T.nilable(T.any(Symbol, String)),
+      block: T.nilable(T.proc.bind(Resource::Patch).void),
+    ).returns(T.any(EmbeddedPatch, ExternalPatch))
+  }
   def self.create(strip, src, &block)
     case strip
     when :DATA
@@ -22,32 +31,38 @@ def self.create(strip, src, &block)
       else
         ExternalPatch.new(strip, &block)
       end
-    when nil
-      raise ArgumentError, "nil value for strip"
-    else
-      raise ArgumentError, "Unexpected value for strip: #{strip.inspect}"
     end
   end
 end
 
 # An abstract class representing a patch embedded into a formula.
 class EmbeddedPatch
   include Utils::Output::Mixin
+  extend T::Helpers
+
+  abstract!
 
+  sig { params(owner: T.nilable(Owner)).returns(T.nilable(Owner)) }
   attr_writer :owner
+
+  sig { returns(T.any(String, Symbol)) }
   attr_reader :strip
 
+  sig { params(strip: T.any(String, Symbol)).void }
   def initialize(strip)
-    @strip = strip
+    @strip = T.let(strip, T.any(String, Symbol))
+    @owner = T.let(nil, T.nilable(Owner))
   end
 
   sig { returns(T::Boolean) }
   def external?
     false
   end
 
+  sig { abstract.returns(String) }
   def contents; end
 
+  sig { void }
   def apply
     data = contents.gsub("@@HOMEBREW_PREFIX@@", HOMEBREW_PREFIX)
     if data.gsub!("HOMEBREW_PREFIX", HOMEBREW_PREFIX)
@@ -66,15 +81,20 @@ def inspect
 
 # A patch at the `__END__` of a formula file.
 class DATAPatch < EmbeddedPatch
+  sig { returns(T.nilable(Pathname)) }
   attr_accessor :path
 
+  sig { params(strip: T.any(String, Symbol)).void }
   def initialize(strip)
     super
-    @path = nil
+    @path = T.let(nil, T.nilable(Pathname))
   end
 
-  sig { returns(String) }
+  sig { override.returns(String) }
   def contents
+    path = self.path
+    raise ArgumentError, "DATAPatch#contents called before path was set!" unless path
+
     data = +""
     path.open("rb") do |f|
       loop do
@@ -91,11 +111,13 @@ def contents
 
 # A string containing a patch.
 class StringPatch < EmbeddedPatch
+  sig { params(strip: T.any(String, Symbol), str: String).void }
   def initialize(strip, str)
     super(strip)
-    @str = str
+    @str = T.let(str, String)
   end
 
+  sig { override.returns(String) }
   def contents
     @str
   end
@@ -107,27 +129,34 @@ class ExternalPatch
 
   extend Forwardable
 
-  attr_reader :resource, :strip
+  sig { returns(Resource::Patch) }
+  attr_reader :resource
+
+  sig { returns(T.any(String, Symbol)) }
+  attr_reader :strip
 
   def_delegators :resource,
                  :url, :fetch, :patch_files, :verify_download_integrity,
                  :cached_download, :downloaded?, :clear_cache
 
+  sig { params(strip: T.any(String, Symbol), block: T.nilable(T.proc.bind(Resource::Patch).void)).void }
   def initialize(strip, &block)
-    @strip    = strip
-    @resource = Resource::Patch.new(&block)
+    @strip    = T.let(strip, T.any(String, Symbol))
+    @resource = T.let(Resource::Patch.new(&block), Resource::Patch)
   end
 
   sig { returns(T::Boolean) }
   def external?
     true
   end
 
+  sig { params(owner: T.nilable(Owner)).void }
   def owner=(owner)
     resource.owner = owner
     resource.version(resource.checksum&.hexdigest || ERB::Util.url_encode(resource.url))
   end
 
+  sig { void }
   def apply
     base_dir = Pathname.pwd
     resource.unpack do

Library/Homebrew/test/patch_spec.rb

@@ -42,16 +42,6 @@
       it { is_expected.to be_a DATAPatch }
       it(:strip) { expect(patch.strip).to eq(:p1) }
     end
-
-    it "raises an error for unknown values" do
-      expect do
-        described_class.create(Object.new)
-      end.to raise_error(ArgumentError)
-
-      expect do
-        described_class.create(Object.new, Object.new)
-      end.to raise_error(ArgumentError)
-    end
   end
 
   describe "#patch_files" do
@@ -81,14 +71,6 @@
     end
   end
 
-  describe EmbeddedPatch do
-    describe "#new" do
-      subject(:patch) { described_class.new(:p1) }
-
-      it(:inspect) { expect(patch.inspect).to eq("#<EmbeddedPatch: :p1>") }
-    end
-  end
-
   describe ExternalPatch do
     subject(:patch) { described_class.new(:p1) { url "file:///my.patch" } }
 

Library/Homebrew/test/resource_spec.rb

@@ -152,15 +152,15 @@
   end
 
   describe "#owner" do
+    let(:owner) { described_class.new("test-owner") }
+
     it "sets the owner" do
-      owner = Object.new
       resource.owner = owner
       expect(resource.owner).to eq(owner)
     end
 
     it "sets its owner to be the patches' owner" do
       resource.patch(:p1) { url "file:///my.patch" }
-      owner = Object.new
       resource.owner = owner
       resource.patches.each do |p|
         expect(p.resource.owner).to eq(owner)