rubocop: require braces for Sorbet sig

Library/Homebrew/.rubocop.yml

@@ -51,3 +51,7 @@ Naming/PredicateName:
 Style/HashAsLastArrayItem:
   Exclude:
     - 'test/utils/spdx_spec.rb'
+
+Style/BlockDelimiters:
+  BracesRequiredMethods:
+    - 'sig'

Library/Homebrew/bintray.rb

@@ -43,7 +43,7 @@ class Bintray
     curl(*args, url, print_stdout: false, secrets: key)
   end
 
-  sig do
+  sig {
     params(local_file:    String,
            repo:          String,
            package:       String,
@@ -51,7 +51,7 @@ class Bintray
            remote_file:   String,
            sha256:        T.nilable(String),
            warn_on_error: T.nilable(T::Boolean)).void
-  end
+  }
   def upload(local_file, repo:, package:, version:, remote_file:, sha256: nil, warn_on_error: false)
     unless File.exist? local_file
       msg = "#{local_file} for upload doesn't exist!"
@@ -78,13 +78,13 @@ class Bintray
     opoo msg
   end
 
-  sig do
+  sig {
     params(repo:          String,
            package:       String,
            version:       String,
            file_count:    T.nilable(Integer),
            warn_on_error: T.nilable(T::Boolean)).void
-  end
+  }
   def publish(repo:, package:, version:, file_count:, warn_on_error: false)
     url = "#{API_URL}/content/#{@bintray_org}/#{repo}/#{package}/#{version}/publish"
     upload_args = %w[--request POST]
@@ -113,12 +113,12 @@ class Bintray
     status_code.start_with?("2")
   end
 
-  sig do
+  sig {
     params(formula:         Formula,
            repo:            String,
            publish_package: T::Boolean,
            warn_on_error:   T::Boolean).returns(String)
-  end
+  }
   def mirror_formula(formula, repo: "mirror", publish_package: false, warn_on_error: false)
     package = Utils::Bottles::Bintray.package formula.name
 
@@ -202,11 +202,11 @@ class Bintray
     EOS
   end
 
-  sig do
+  sig {
     params(bottles_hash:    T::Hash[String, T.untyped],
            publish_package: T::Boolean,
            warn_on_error:   T.nilable(T::Boolean)).void
-  end
+  }
   def upload_bottles(bottles_hash, publish_package: false, warn_on_error: false)
     formula_packaged = {}
 

Library/Homebrew/cask/artifact/relocated.rb

@@ -41,10 +41,10 @@ module Cask
 
       attr_reader :source, :target
 
-      sig do
+      sig {
         params(cask: Cask, source: T.nilable(T.any(String, Pathname)), target: T.nilable(T.any(String, Pathname)))
           .void
-      end
+      }
       def initialize(cask, source, target: nil)
         super(cask)
 

Library/Homebrew/cask/cmd/upgrade.rb

@@ -57,7 +57,7 @@ module Cask
         )
       end
 
-      sig do
+      sig {
         params(
           casks:          Cask,
           args:           Homebrew::CLI::Args,
@@ -70,7 +70,7 @@ module Cask
           quarantine:     T.nilable(T::Boolean),
           require_sha:    T.nilable(T::Boolean),
         ).returns(T::Boolean)
-      end
+      }
       def self.upgrade_casks(
         *casks,
         args:,

Library/Homebrew/cask/config.rb

@@ -72,10 +72,10 @@ module Cask
       )
     end
 
-    sig do
+    sig {
       params(config: T::Enumerable[[T.any(String, Symbol), T.any(String, Pathname, T::Array[String])]])
         .returns(T::Hash[Symbol, T.any(String, Pathname, T::Array[String])])
-    end
+    }
     def self.canonicalize(config)
       config.map do |k, v|
         key = k.to_sym
@@ -91,14 +91,14 @@ module Cask
     sig { returns(T::Hash[Symbol, T.any(String, Pathname, T::Array[String])]) }
     attr_accessor :explicit
 
-    sig do
+    sig {
       params(
         default:             T.nilable(T::Hash[Symbol, T.any(String, Pathname, T::Array[String])]),
         env:                 T.nilable(T::Hash[Symbol, T.any(String, Pathname, T::Array[String])]),
         explicit:            T::Hash[Symbol, T.any(String, Pathname, T::Array[String])],
         ignore_invalid_keys: T::Boolean,
       ).void
-    end
+    }
     def initialize(default: nil, env: nil, explicit: {}, ignore_invalid_keys: false)
       @default = self.class.canonicalize(self.class.defaults.merge(default)) if default
       @env = self.class.canonicalize(env) if env

Library/Homebrew/cask/url.rb

@@ -16,7 +16,7 @@ class URL
   extend Forwardable
   def_delegators :uri, :path, :scheme, :to_s
 
-  sig do
+  sig {
     params(
       uri:             T.any(URI::Generic, String),
       verified:        T.nilable(String),
@@ -34,7 +34,7 @@ class URL
       from_block:      T::Boolean,
       caller_location: Thread::Backtrace::Location,
     ).returns(T.untyped)
-  end
+  }
   def initialize(
     uri,
     verified: nil,

Library/Homebrew/cli/named_args.rb

@@ -42,10 +42,10 @@ module Homebrew
       # Convert named arguments to {Formula} or {Cask} objects.
       # If both a formula and cask with the same name exist, returns
       # the formula and prints a warning unless `only` is specified.
-      sig do
+      sig {
         params(only: T.nilable(Symbol), ignore_unavailable: T.nilable(T::Boolean), method: T.nilable(Symbol))
           .returns(T::Array[T.any(Formula, Keg, Cask::Cask)])
-      end
+      }
       def to_formulae_and_casks(only: parent&.only_formula_or_cask, ignore_unavailable: nil, method: nil)
         @to_formulae_and_casks ||= {}
         @to_formulae_and_casks[only] ||= downcased_unique_named.flat_map do |name|
@@ -175,10 +175,10 @@ module Homebrew
         end
       end
 
-      sig do
+      sig {
         params(only: T.nilable(Symbol), ignore_unavailable: T.nilable(T::Boolean), all_kegs: T.nilable(T::Boolean))
           .returns([T::Array[Keg], T::Array[Cask::Cask]])
-      end
+      }
       def to_kegs_to_casks(only: parent&.only_formula_or_cask, ignore_unavailable: nil, all_kegs: nil)
         method = all_kegs ? :kegs : :keg
         @to_kegs_to_casks ||= {}

Library/Homebrew/cli/parser.rb

@@ -355,14 +355,14 @@ module Homebrew
         @formula_options = true
       end
 
-      sig do
+      sig {
         params(
           type:   T.any(Symbol, T::Array[String], T::Array[Symbol]),
           number: T.nilable(Integer),
           min:    T.nilable(Integer),
           max:    T.nilable(Integer),
         ).void
-      end
+      }
       def named_args(type = nil, number: nil, min: nil, max: nil)
         if number.present? && (min.present? || max.present?)
           raise ArgumentError, "Do not specify both `number` and `min` or `max`"

Library/Homebrew/dev-cmd/bump-unversioned-casks.rb

@@ -84,10 +84,10 @@ module Homebrew
     end
   end
 
-  sig do
+  sig {
     params(cask: Cask::Cask, state: T::Hash[String, T.untyped], dry_run: T.nilable(T::Boolean))
       .returns(T.nilable(T::Hash[String, T.untyped]))
-  end
+  }
   def self.bump_unversioned_cask(cask, state:, dry_run:)
     ohai "Checking #{cask.full_name}"
 

Library/Homebrew/extend/ENV.rb

@@ -31,7 +31,7 @@ module EnvActivation
     end
   end
 
-  sig do
+  sig {
     params(
       env:          T.nilable(String),
       cc:           T.nilable(String),
@@ -39,7 +39,7 @@ module EnvActivation
       bottle_arch:  T.nilable(String),
       _block:       T.proc.returns(T.untyped),
     ).returns(T.untyped)
-  end
+  }
   def with_build_environment(env: nil, cc: nil, build_bottle: false, bottle_arch: nil, &_block)
     old_env = to_hash.dup
     tmp_env = to_hash.dup.extend(EnvActivation)

Library/Homebrew/extend/ENV.rbi

@@ -24,10 +24,10 @@ module EnvMethods
   sig { params(key: String).returns(T.nilable(String)) }
   def delete(key); end
 
-  sig do
+  sig {
     params(other: T.any(T::Hash[String, String], Sorbet::Private::Static::ENVClass))
       .returns(Sorbet::Private::Static::ENVClass)
-  end
+  }
   def replace(other); end
 
   sig { returns(T::Hash[String, String]) }

Library/Homebrew/extend/ENV/shared.rb

@@ -33,14 +33,14 @@ module SharedEnvExtension
   ].freeze
   private_constant :SANITIZED_VARS
 
-  sig do
+  sig {
     params(
       formula:      T.nilable(Formula),
       cc:           T.nilable(String),
       build_bottle: T.nilable(T::Boolean),
       bottle_arch:  T.nilable(T::Boolean),
     ).void
-  end
+  }
   def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil)
     @formula = formula
     @cc = cc

Library/Homebrew/extend/ENV/std.rb

@@ -14,14 +14,14 @@ module Stdenv
   SAFE_CFLAGS_FLAGS = "-w -pipe"
 
   # @private
-  sig do
+  sig {
     params(
       formula:      T.nilable(Formula),
       cc:           T.nilable(String),
       build_bottle: T.nilable(T::Boolean),
       bottle_arch:  T.nilable(T::Boolean),
     ).void
-  end
+  }
   def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil)
     super
 

Library/Homebrew/extend/ENV/super.rb

@@ -42,14 +42,14 @@ module Superenv
   end
 
   # @private
-  sig do
+  sig {
     params(
       formula:      T.nilable(Formula),
       cc:           T.nilable(String),
       build_bottle: T.nilable(T::Boolean),
       bottle_arch:  T.nilable(T::Boolean),
     ).void
-  end
+  }
   def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil)
     super
     send(compiler)

Library/Homebrew/extend/pathname.rb

@@ -85,12 +85,12 @@ class Pathname
   BOTTLE_EXTNAME_RX = /(\.[a-z0-9_]+\.bottle\.(\d+\.)?tar\.gz)$/.freeze
 
   # Moves a file from the original location to the {Pathname}'s.
-  sig do
+  sig {
     params(sources: T.any(
       Resource, Resource::Partial, String, Pathname,
       T::Array[T.any(String, Pathname)], T::Hash[T.any(String, Pathname), String]
     )).void
-  end
+  }
   def install(*sources)
     sources.each do |src|
       case src
@@ -140,11 +140,11 @@ class Pathname
   private :install_p
 
   # Creates symlinks to sources in this folder.
-  sig do
+  sig {
     params(
       sources: T.any(String, Pathname, T::Array[T.any(String, Pathname)], T::Hash[T.any(String, Pathname), String]),
     ).void
-  end
+  }
   def install_symlink(*sources)
     sources.each do |src|
       case src
@@ -309,11 +309,11 @@ class Pathname
 
   alias to_str to_s
 
-  sig do
+  sig {
     type_parameters(:U).params(
       _block: T.proc.params(path: Pathname).returns(T.type_parameter(:U)),
     ).returns(T.type_parameter(:U))
-  end
+  }
   def cd(&_block)
     Dir.chdir(self) { yield self }
   end
@@ -413,14 +413,14 @@ class Pathname
   end
 
   # Writes an exec script that invokes a Java jar.
-  sig do
+  sig {
     params(
       target_jar:   T.any(String, Pathname),
       script_name:  T.any(String, Pathname),
       java_opts:    String,
       java_version: T.nilable(String),
     ).returns(Integer)
-  end
+  }
   def write_jar_script(target_jar, script_name, java_opts = "", java_version: nil)
     (self/script_name).write <<~EOS
       #!/bin/bash

Library/Homebrew/livecheck/livecheck.rb

@@ -62,7 +62,7 @@ module Homebrew
 
     # Executes the livecheck logic for each formula/cask in the
     # `formulae_and_casks_to_check` array and prints the results.
-    sig do
+    sig {
       params(
         formulae_and_casks_to_check: T::Enumerable[T.any(Formula, Cask::Cask)],
         full_name:                   T::Boolean,
@@ -72,7 +72,7 @@ module Homebrew
         quiet:                       T::Boolean,
         verbose:                     T::Boolean,
       ).void
-    end
+    }
     def run_checks(
       formulae_and_casks_to_check,
       full_name: false, json: false, newer_only: false, debug: false, quiet: false, verbose: false
@@ -260,7 +260,7 @@ module Homebrew
       full_name ? formula.full_name : formula.name
     end
 
-    sig do
+    sig {
       params(
         formula_or_cask: T.any(Formula, Cask::Cask),
         status_str:      String,
@@ -268,7 +268,7 @@ module Homebrew
         full_name:       T::Boolean,
         verbose:         T::Boolean,
       ).returns(Hash)
-    end
+    }
     def status_hash(formula_or_cask, status_str, messages = nil, full_name: false, verbose: false)
       formula = formula_or_cask if formula_or_cask.is_a?(Formula)
       cask = formula_or_cask if formula_or_cask.is_a?(Cask::Cask)
@@ -311,12 +311,12 @@ module Homebrew
       puts "#{formula_or_cask_s} : #{current_s} ==> #{latest_s}"
     end
 
-    sig do
+    sig {
       params(
         livecheck_url:   T.any(String, Symbol),
         formula_or_cask: T.any(Formula, Cask::Cask),
       ).returns(T.nilable(String))
-    end
+    }
     def livecheck_url_to_string(livecheck_url, formula_or_cask)
       case livecheck_url
       when String
@@ -396,7 +396,7 @@ module Homebrew
 
     # Identifies the latest version of the formula and returns a Hash containing
     # the version information. Returns nil if a latest version couldn't be found.
-    sig do
+    sig {
       params(
         formula_or_cask: T.any(Formula, Cask::Cask),
         json:            T::Boolean,
@@ -404,7 +404,7 @@ module Homebrew
         verbose:         T::Boolean,
         debug:           T::Boolean,
       ).returns(T.nilable(Hash))
-    end
+    }
     def latest_version(formula_or_cask, json: false, full_name: false, verbose: false, debug: false)
       formula = formula_or_cask if formula_or_cask.is_a?(Formula)
       cask = formula_or_cask if formula_or_cask.is_a?(Cask::Cask)

Library/Homebrew/livecheck/skip_conditions.rb

@@ -14,14 +14,14 @@ module Homebrew
 
       module_function
 
-      sig do
+      sig {
         params(
           formula_or_cask: T.any(Formula, Cask::Cask),
           livecheckable:   T::Boolean,
           full_name:       T::Boolean,
           verbose:         T::Boolean,
         ).returns(Hash)
-      end
+      }
       def formula_or_cask_skip(formula_or_cask, livecheckable, full_name: false, verbose: false)
         formula = formula_or_cask if formula_or_cask.is_a?(Formula)
 
@@ -51,14 +51,14 @@ module Homebrew
         Livecheck.status_hash(formula_or_cask, "skipped", skip_messages, full_name: full_name, verbose: verbose)
       end
 
-      sig do
+      sig {
         params(
           formula:        Formula,
           _livecheckable: T::Boolean,
           full_name:      T::Boolean,
           verbose:        T::Boolean,
         ).returns(Hash)
-      end
+      }
       def formula_head_only(formula, _livecheckable, full_name: false, verbose: false)
         return {} if !formula.head_only? || formula.any_version_installed?
 
@@ -71,84 +71,84 @@ module Homebrew
         )
       end
 
-      sig do
+      sig {
         params(
           formula:       Formula,
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
         ).returns(Hash)
-      end
+      }
       def formula_deprecated(formula, livecheckable, full_name: false, verbose: false)
         return {} if !formula.deprecated? || livecheckable
 
         Livecheck.status_hash(formula, "deprecated", full_name: full_name, verbose: verbose)
       end
 
-      sig do
+      sig {
         params(
           formula:       Formula,
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
         ).returns(Hash)
-      end
+      }
       def formula_disabled(formula, livecheckable, full_name: false, verbose: false)
         return {} if !formula.disabled? || livecheckable
 
         Livecheck.status_hash(formula, "disabled", full_name: full_name, verbose: verbose)
       end
 
-      sig do
+      sig {
         params(
           formula:       Formula,
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
         ).returns(Hash)
-      end
+      }
       def formula_versioned(formula, livecheckable, full_name: false, verbose: false)
         return {} if !formula.versioned_formula? || livecheckable
 
         Livecheck.status_hash(formula, "versioned", full_name: full_name, verbose: verbose)
       end
 
-      sig do
+      sig {
         params(
           cask:          Cask::Cask,
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
         ).returns(Hash)
-      end
+      }
       def cask_discontinued(cask, livecheckable, full_name: false, verbose: false)
         return {} if !cask.discontinued? || livecheckable
 
         Livecheck.status_hash(cask, "discontinued", full_name: full_name, verbose: verbose)
       end
 
-      sig do
+      sig {
         params(
           cask:          Cask::Cask,
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
         ).returns(Hash)
-      end
+      }
       def cask_version_latest(cask, livecheckable, full_name: false, verbose: false)
         return {} if !(cask.present? && cask.version&.latest?) || livecheckable
 
         Livecheck.status_hash(cask, "latest", full_name: full_name, verbose: verbose)
       end
 
-      sig do
+      sig {
         params(
           cask:          Cask::Cask,
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
         ).returns(Hash)
-      end
+      }
       def cask_url_unversioned(cask, livecheckable, full_name: false, verbose: false)
         return {} if !(cask.present? && cask.url&.unversioned?) || livecheckable
 
@@ -175,13 +175,13 @@ module Homebrew
       # If a formula/cask should be skipped, we return a hash from
       # `Livecheck#status_hash`, which contains a `status` type and sometimes
       # error `messages`.
-      sig do
+      sig {
         params(
           formula_or_cask: T.any(Formula, Cask::Cask),
           full_name:       T::Boolean,
           verbose:         T::Boolean,
         ).returns(Hash)
-      end
+      }
       def skip_information(formula_or_cask, full_name: false, verbose: false)
         livecheckable = formula_or_cask.livecheckable?
 

Library/Homebrew/livecheck/strategy/page_match.rb

@@ -77,14 +77,14 @@ module Homebrew
         # @param provided_content [String] page content to use in place of
         #   fetching via Strategy#page_content
         # @return [Hash]
-        sig do
+        sig {
           params(
             url:              String,
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
             block:            T.nilable(T.proc.params(arg0: String).returns(T.any(T::Array[String], String))),
           ).returns(T::Hash[Symbol, T.untyped])
-        end
+        }
         def self.find_versions(url, regex, provided_content = nil, &block)
           match_data = { matches: {}, regex: regex, url: url }
 

Library/Homebrew/system_command.rb

@@ -64,7 +64,7 @@ class SystemCommand
     result
   end
 
-  sig do
+  sig {
     params(
       executable:   T.any(String, Pathname),
       args:         T::Array[T.any(String, Integer, Float, URI::Generic)],
@@ -79,7 +79,7 @@ class SystemCommand
       secrets:      T.any(String, T::Array[String]),
       chdir:        T.any(String, Pathname),
     ).void
-  end
+  }
   def initialize(executable, args: [], sudo: false, env: {}, input: [], must_succeed: false,
                  print_stdout: false, print_stderr: true, debug: nil, verbose: nil, secrets: [], chdir: T.unsafe(nil))
     require "extend/ENV"
@@ -224,14 +224,14 @@ class SystemCommand
 
     attr_accessor :command, :status, :exit_status
 
-    sig do
+    sig {
       params(
         command: T::Array[String],
         output:  T::Array[[Symbol, String]],
         status:  Process::Status,
         secrets: T::Array[String],
       ).void
-    end
+    }
     def initialize(command, output, status, secrets:)
       @command       = command
       @output        = output

Library/Homebrew/unpack_strategy/zip.rb

@@ -22,10 +22,10 @@ module UnpackStrategy
 
     private
 
-    sig do
+    sig {
       override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean)
               .returns(SystemCommand::Result)
-    end
+    }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       quiet_flags = verbose ? [] : ["-qq"]
       result = system_command! "unzip",

Library/Homebrew/utils/ast.rb

@@ -49,14 +49,14 @@ module Utils
       [processed_source, root_node]
     end
 
-    sig do
+    sig {
       params(
         component_name: Symbol,
         component_type: Symbol,
         target_name:    Symbol,
         target_type:    T.nilable(Symbol),
       ).returns(T::Boolean)
-    end
+    }
     def component_match?(component_name:, component_type:, target_name:, target_type: nil)
       component_name == target_name && (target_type.nil? || component_type == target_type)
     end

Library/Homebrew/utils/git_repository.rb

@@ -4,13 +4,13 @@
 module Utils
   extend T::Sig
 
-  sig do
+  sig {
     params(
       repo:   T.any(String, Pathname),
       length: T.nilable(Integer),
       safe:   T::Boolean,
     ).returns(T.nilable(String))
-  end
+  }
   def self.git_head(repo = Pathname.pwd, length: nil, safe: true)
     return git_short_head(repo, length: length) if length.present?
 
@@ -18,13 +18,13 @@ module Utils
     repo.git_head(safe: safe)
   end
 
-  sig do
+  sig {
     params(
       repo:   T.any(String, Pathname),
       length: T.nilable(Integer),
       safe:   T::Boolean,
     ).returns(T.nilable(String))
-  end
+  }
   def self.git_short_head(repo = Pathname.pwd, length: nil, safe: true)
     repo = Pathname(repo).extend(GitRepositoryExtension)
     repo.git_short_head(length: length, safe: safe)

Library/Homebrew/utils/github/actions.rb

@@ -31,12 +31,12 @@ module GitHub
         path.realpath.relative_path_from(workspace)
       end
 
-      sig do
+      sig {
         params(
           type: Symbol, message: String,
           file: T.nilable(T.any(String, Pathname)), line: T.nilable(Integer), column: T.nilable(Integer)
         ).void
-      end
+      }
       def initialize(type, message, file: nil, line: nil, column: nil)
         raise ArgumentError, "Unsupported type: #{type.inspect}" unless [:warning, :error].include?(type)
 

Library/Homebrew/utils/inreplace.rb

@@ -40,14 +40,14 @@ module Utils
     #
     # @see StringInreplaceExtension
     # @api public
-    sig do
+    sig {
       params(
         paths:        T.any(T::Array[T.untyped], String, Pathname),
         before:       T.nilable(T.any(Regexp, String)),
         after:        T.nilable(T.any(String, Symbol)),
         audit_result: T::Boolean,
       ).void
-    end
+    }
     def inreplace(paths, before = nil, after = nil, audit_result = true) # rubocop:disable Style/OptionalBooleanParameter
       after = after.to_s if after.is_a? Symbol
 

Library/Homebrew/utils/pypi.rb

@@ -119,7 +119,7 @@ module PyPI
   end
 
   # Return true if resources were checked (even if no change).
-  sig do
+  sig {
     params(
       formula:                  Formula,
       version:                  T.nilable(String),
@@ -130,7 +130,7 @@ module PyPI
       silent:                   T.nilable(T::Boolean),
       ignore_non_pypi_packages: T.nilable(T::Boolean),
     ).returns(T.nilable(T::Boolean))
-  end
+  }
   def update_python_resources!(formula, version: nil, package_name: nil, extra_packages: nil, exclude_packages: nil,
                                print_only: false, silent: false, ignore_non_pypi_packages: false)
 

Library/Homebrew/utils/string_inreplace_extension.rb

@@ -28,10 +28,10 @@ class StringInreplaceExtension
   # Same as `String#gsub!`, but warns if nothing was replaced.
   #
   # @api public
-  sig do
+  sig {
     params(before: T.any(Regexp, String), after: T.nilable(String), audit_result: T::Boolean)
       .returns(T.nilable(String))
-  end
+  }
   def gsub!(before, after, audit_result = true) # rubocop:disable Style/OptionalBooleanParameter
     result = inreplace_string.gsub!(before, after)
     errors << "expected replacement of #{before.inspect} with #{after.inspect}" if audit_result && result.nil?