Try non-nil params

Author: dduugg

Library/Homebrew/service.rb

@@ -23,7 +23,7 @@ class Service
     PROCESS_TYPE_ADAPTIVE = :adaptive
 
     KEEP_ALIVE_KEYS = [:always, :successful_exit, :crashed, :path].freeze
-    SOCKET_STRING_REGEX = %r{^([a-z]+)://(.+):([0-9]+)$}i
+    SOCKET_STRING_REGEX = %r{^(?<type>[a-z]+)://(?<host>.+):(?<port>[0-9]+)$}i
 
     RunParam = T.type_alias { T.nilable(T.any(T::Array[T.any(String, Pathname)], String, Pathname)) }
     Sockets = T.type_alias { T::Hash[Symbol, { host: String, port: String, type: String }] }
@@ -107,44 +107,44 @@ def run(command = nil, macos: nil, linux: nil)
       end
     end
 
-    sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
-    def working_dir(path = nil)
+    sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+    def working_dir(path = T.unsafe(nil))
       if path
         @working_dir = path.to_s
       else
         @working_dir
       end
     end
 
-    sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
-    def root_dir(path = nil)
+    sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+    def root_dir(path = T.unsafe(nil))
       if path
         @root_dir = path.to_s
       else
         @root_dir
       end
     end
 
-    sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
-    def input_path(path = nil)
+    sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+    def input_path(path = T.unsafe(nil))
       if path
         @input_path = path.to_s
       else
         @input_path
       end
     end
 
-    sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
-    def log_path(path = nil)
+    sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+    def log_path(path = T.unsafe(nil))
       if path
         @log_path = path.to_s
       else
         @log_path
       end
     end
 
-    sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
-    def error_log_path(path = nil)
+    sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+    def error_log_path(path = T.unsafe(nil))
       if path
         @error_log_path = path.to_s
       else
@@ -153,10 +153,10 @@ def error_log_path(path = nil)
     end
 
     sig {
-      params(value: T.nilable(T.any(T::Boolean, T::Hash[Symbol, T.untyped])))
+      params(value: T.any(T::Boolean, T::Hash[Symbol, T.untyped]))
         .returns(T.nilable(T::Hash[Symbol, T.untyped]))
     }
-    def keep_alive(value = nil)
+    def keep_alive(value = T.unsafe(nil))
       case value
       when nil
         @keep_alive
@@ -171,8 +171,8 @@ def keep_alive(value = nil)
       end
     end
 
-    sig { params(value: T.nilable(T::Boolean)).returns(T::Boolean) }
-    def require_root(value = nil)
+    sig { params(value: T::Boolean).returns(T::Boolean) }
+    def require_root(value = T.unsafe(nil))
       if value.nil?
         @require_root
       else
@@ -186,8 +186,8 @@ def requires_root?
       @require_root.present? && @require_root == true
     end
 
-    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-    def run_at_load(value = nil)
+    sig { params(value: T::Boolean).returns(T.nilable(T::Boolean)) }
+    def run_at_load(value = T.unsafe(nil))
       if value.nil?
         @run_at_load
       else
@@ -196,32 +196,30 @@ def run_at_load(value = nil)
     end
 
     sig {
-      params(value: T.nilable(T.any(String, T::Hash[Symbol, String])))
+      params(value: T.any(String, T::Hash[Symbol, String]))
         .returns(T::Hash[Symbol, T::Hash[Symbol, String]])
     }
-    def sockets(value = nil)
+    def sockets(value = T.unsafe(nil))
       return @sockets if value.nil?
 
-      @sockets = case value
+      value_hash = case value
       when String
         { listeners: value }
       when Hash
         value
-      end.transform_values do |socket_string|
+      end
+
+      @sockets = T.must(value_hash).transform_values do |socket_string|
         match = socket_string.match(SOCKET_STRING_REGEX)
         raise TypeError, "Service#sockets a formatted socket definition as <type>://<host>:<port>" unless match
 
-        type = T.must(match[1])
-        host = T.must(match[2])
-        port = T.must(match[3])
-
         begin
-          IPAddr.new(host)
+          IPAddr.new(match[:host])
         rescue IPAddr::InvalidAddressError
           raise TypeError, "Service#sockets expects a valid ipv4 or ipv6 host address"
         end
 
-        { host:, port:, type: }
+        { host: match[:host], port: match[:port], type: match[:type] }
       end
     end
 
@@ -231,26 +229,26 @@ def keep_alive?
       !@keep_alive.empty? && @keep_alive[:always] != false
     end
 
-    sig { params(value: T.nilable(T::Boolean)).returns(T::Boolean) }
-    def launch_only_once(value = nil)
+    sig { params(value: T::Boolean).returns(T::Boolean) }
+    def launch_only_once(value = T.unsafe(nil))
       if value.nil?
         @launch_only_once
       else
         @launch_only_once = value
       end
     end
 
-    sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def restart_delay(value = nil)
-      if restart_delay
+    sig { params(value: Integer).returns(T.nilable(Integer)) }
+    def restart_delay(value = T.unsafe(nil))
+      if value
         @restart_delay = value
       else
         @restart_delay
       end
     end
 
-    sig { params(value: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-    def process_type(value = nil)
+    sig { params(value: Symbol).returns(T.nilable(Symbol)) }
+    def process_type(value = T.unsafe(nil))
       case value
       when nil
         @process_type
@@ -263,8 +261,8 @@ def process_type(value = nil)
       end
     end
 
-    sig { params(value: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-    def run_type(value = nil)
+    sig { params(value: Symbol).returns(T.nilable(Symbol)) }
+    def run_type(value = T.unsafe(nil))
       case value
       when nil
         @run_type
@@ -275,17 +273,17 @@ def run_type(value = nil)
       end
     end
 
-    sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def interval(value = nil)
+    sig { params(value: Integer).returns(T.nilable(Integer)) }
+    def interval(value = T.unsafe(nil))
       if value
         @interval = value
       else
         @interval
       end
     end
 
-    sig { params(value: T.nilable(String)).returns(T::Hash[Symbol, T.any(Integer, String)]) }
-    def cron(value = nil)
+    sig { params(value: String).returns(T::Hash[Symbol, T.any(Integer, String)]) }
+    def cron(value = T.unsafe(nil))
       if value
         @cron = parse_cron(value)
       else
@@ -344,8 +342,8 @@ def environment_variables(variables = {})
       @environment_variables = variables.transform_values(&:to_s)
     end
 
-    sig { params(value: T.nilable(T::Boolean)).returns(T::Boolean) }
-    def macos_legacy_timers(value = nil)
+    sig { params(value: T::Boolean).returns(T::Boolean) }
+    def macos_legacy_timers(value = T.unsafe(nil))
       if value.nil?
         @macos_legacy_timers
       else