Merge pull request #21413 from hyuraku/cache_store-typed-strict

cache_store: `typed: strict`

Author: MikeMcQuaid

Library/Homebrew/cache_store.rb

@@ -1,4 +1,4 @@
-# typed: true # rubocop:todo Sorbet/StrictSigil
+# typed: strict
 # frozen_string_literal: true
 
 require "json"
@@ -13,8 +13,16 @@ class CacheStoreDatabase
   #
   # @param  [Symbol] type
   # @yield  [CacheStoreDatabase] self
-  def self.use(type)
-    @db_type_reference_hash ||= {}
+  sig {
+    type_parameters(:U)
+      .params(
+        type: Symbol,
+        _blk: T.proc.params(arg0: CacheStoreDatabase).returns(T.type_parameter(:U)),
+      )
+      .returns(T.type_parameter(:U))
+  }
+  def self.use(type, &_blk)
+    @db_type_reference_hash ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
     @db_type_reference_hash[type] ||= {}
     type_ref = @db_type_reference_hash[type]
 
@@ -42,25 +50,29 @@ def self.use(type)
   #
   # @param  [Symbol] type
   # @return [nil]
+  sig { params(type: Symbol).void }
   def initialize(type)
-    @type = type
-    @dirty = false
+    @type = T.let(type, Symbol)
+    @dirty = T.let(false, T.nilable(T::Boolean))
   end
 
   # Sets a value in the underlying database (and creates it if necessary).
+  sig { params(key: T.anything, value: T.anything).void }
   def set(key, value)
     dirty!
     db[key] = value
   end
 
   # Gets a value from the underlying database (if it already exists).
+  sig { params(key: T.anything).returns(T.untyped) }
   def get(key)
     return unless created?
 
     db[key]
   end
 
   # Deletes a value from the underlying database (if it already exists).
+  sig { params(key: T.anything).void }
   def delete(key)
     return unless created?
 
@@ -69,6 +81,7 @@ def delete(key)
   end
 
   # Deletes all content from the underlying database (if it already exists).
+  sig { void }
   def clear!
     return unless created?
 
@@ -77,6 +90,7 @@ def clear!
   end
 
   # Closes the underlying database (if it is created and open).
+  sig { void }
   def write_if_dirty!
     return unless dirty?
 
@@ -87,13 +101,15 @@ def write_if_dirty!
   # Returns `true` if the cache file has been created for the given `@type`.
   #
   # @return [Boolean]
+  sig { returns(T::Boolean) }
   def created?
     cache_path.exist?
   end
 
   # Returns the modification time of the cache file (if it already exists).
   #
   # @return [Time]
+  sig { returns(T.nilable(Time)) }
   def mtime
     return unless created?
 
@@ -102,21 +118,24 @@ def mtime
 
   # Performs a `select` on the underlying database.
   #
-  # @return [Array]
+  # @return [Hash]
+  sig { params(block: T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(BasicObject)).returns(T::Hash[T.untyped, T.untyped]) }
   def select(&block)
     db.select(&block)
   end
 
   # Returns `true` if the cache is empty.
   #
   # @return [Boolean]
+  sig { returns(T::Boolean) }
   def empty?
     db.empty?
   end
 
   # Performs a `each_key` on the underlying database.
   #
-  # @return [Array]
+  # @return [Hash]
+  sig { params(block: T.proc.params(arg0: T.untyped).returns(BasicObject)).returns(T::Hash[T.untyped, T.untyped]) }
   def each_key(&block)
     db.each_key(&block)
   end
@@ -128,33 +147,41 @@ def each_key(&block)
   # corresponding to the `@type` instance variable.
   #
   # @return [Hash] db
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
   def db
-    @db ||= begin
-      JSON.parse(cache_path.read) if created?
+    @db ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
+    return @db if !@db.empty? || !created?
+
+    begin
+      result = JSON.parse(cache_path.read)
+      @db = result if result.is_a?(Hash)
     rescue JSON::ParserError
-      nil
+      # Ignore parse errors
     end
-    @db ||= {}
+    @db
   end
 
   # The path where the database resides in the `HOMEBREW_CACHE` for the given
   # `@type`.
   #
-  # @return [String]
+  # @return [Pathname]
+  sig { returns(Pathname) }
   def cache_path
     HOMEBREW_CACHE/"#{@type}.json"
   end
 
   # Sets that the cache needs to be written to disk.
+  sig { void }
   def dirty!
     @dirty = true
   end
 
   # Returns `true` if the cache needs to be written to disk.
   #
   # @return [Boolean]
+  sig { returns(T::Boolean) }
   def dirty?
-    @dirty
+    !!@dirty
   end
 end
 
@@ -165,34 +192,39 @@ def dirty?
 class CacheStore
   # @param  [CacheStoreDatabase] database
   # @return [nil]
+  sig { params(database: CacheStoreDatabase).void }
   def initialize(database)
-    @database = database
+    @database = T.let(database, CacheStoreDatabase)
   end
 
   # Inserts new values or updates existing cached values to persistent storage.
   #
   # @abstract
-  def update!(*)
+  sig { params(args: T.anything).void }
+  def update!(*args)
     raise NotImplementedError
   end
 
   # Fetches cached values in persistent storage according to the type of data
   # stored.
   #
   # @abstract
-  def fetch(*)
+  sig { params(args: T.anything).returns(T.untyped) }
+  def fetch(*args)
     raise NotImplementedError
   end
 
   # Deletes data from the cache based on a condition defined in a concrete class.
   #
   # @abstract
-  def delete!(*)
+  sig { params(args: T.anything).void }
+  def delete!(*args)
     raise NotImplementedError
   end
 
   protected
 
   # @return [CacheStoreDatabase]
+  sig { returns(CacheStoreDatabase) }
   attr_reader :database
 end