Class: Tap Private

124
125
126
127

# File 'tap.rb', line 124

def self.allowed_taps
  cache_key = :"allowed_taps_#{Homebrew::EnvConfig.allowed_taps.to_s.tr("", "_")}"
  cache[cache_key] ||= tap_list_references(Homebrew::EnvConfig.allowed_taps.to_s, "HOMEBREW_ALLOWED_TAPS")
end

1374
1375
1376

# File 'tap.rb', line 1374

def self.core_taps
  [CoreTap.instance, CoreCaskTap.instance].freeze
end

1382
1383
1384
1385
1386
1387
1388
1389
1390

# File 'tap.rb', line 1382

def self.each(&block)
  return to_enum unless block_given?

  if Homebrew::EnvConfig.no_install_from_api?
    installed.each(&block)
  else
    all.each(&block)
  end
end

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# File 'tap.rb', line 59

def self.fetch(user, repository = T.unsafe(nil))
  user, repository = user.split("/", 2) if repository.nil?

  if [user, repository].any? { |part| part.nil? || part.include?("/") }
    raise InvalidNameError, "Invalid tap name: '#{[*user, *repository].join("/")}'"
  end

  user = T.must(user)

  # We special case homebrew and linuxbrew so that users don't have to shift in a terminal.
  user = user.capitalize if ["homebrew", "linuxbrew"].include?(user)
  repository = repository.sub(HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX, "")

  return CoreTap.instance if ["Homebrew", "Linuxbrew"].include?(user) && ["core", "homebrew"].include?(repository)
  return CoreCaskTap.instance if user == "Homebrew" && repository == "cask"

  cache_key = "#{user}/#{repository}".downcase
  cache.fetch(cache_key) { |key| cache[key] = new(user, repository) }
end

130
131
132
133

# File 'tap.rb', line 130

def self.forbidden_taps
  cache_key = :"forbidden_taps_#{Homebrew::EnvConfig.forbidden_taps.to_s.tr("", "_")}"
  cache[cache_key] ||= tap_list_references(Homebrew::EnvConfig.forbidden_taps.to_s, "HOMEBREW_FORBIDDEN_TAPS")
end

83
84
85
86
87
88
89
90
91

# File 'tap.rb', line 83

def self.from_path(path)
  match = File.expand_path(path).match(HOMEBREW_TAP_PATH_REGEX)

  return unless match
  return unless (user = match[:user])
  return unless (repository = match[:repository])

  fetch(user, repository)
end

1359
1360
1361
1362
1363
1364
1365

# File 'tap.rb', line 1359

def self.installed
  cache[:installed] ||= if HOMEBREW_TAP_DIRECTORY.directory?
    HOMEBREW_TAP_DIRECTORY.subdirs.flat_map(&:subdirs).map { from_path(it) }
  else
    []
  end
end

168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

# File 'tap.rb', line 168

def self.normalize_remote(remote)
  return if remote.blank?

  remote = remote.strip.downcase

  # Canonicalise every GitHub remote form to `https://github.com/<owner>/<repo>` so SSH and
  # HTTPS remotes for the same repository compare equal.
  remote = remote.sub(GITHUB_REMOTE_PREFIX_REGEX, "https://github.com/")

  # Only strip `.git`/trailing slashes for hosts where this is known to be safe.
  host = remote[REMOTE_HOST_REGEX, 1]
  return remote unless NORMALIZE_REMOTE_HOSTS.include?(host)

  remote.sub(%r{/+\z}, "").delete_suffix(".git")
end

141
142
143

# File 'tap.rb', line 141

def self.remote_reference?(reference)
  reference.match?(%r{\A[^/]+:.}) || reference.start_with?("/", ".", "~")
end

189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

# File 'tap.rb', line 189

def self.remote_to_reference(url)
  normalised = normalize_remote(url)
  return if normalised.blank?

  match = normalised.match(HOMEBREW_TAP_REPOSITORY_REGEX)
  return normalised unless match

  remote_repository = match[:remote_repository]
  return normalised unless remote_repository

  tap = fetch(remote_repository)
  if same_remote?(normalised, tap.default_remote)
    tap.name
  else
    normalised
  end
rescue InvalidNameError
  normalised
end

210
211
212
213

# File 'tap.rb', line 210

def self.same_remote?(first, second)
  first = normalize_remote(first)
  first.present? && first == normalize_remote(second)
end

218
219
220
221
222
223
224
225
226
227

# File 'tap.rb', line 218

def self.tap_list_references(env_taps, env_var)
  env_taps.split.filter_map do |reference|
    next reference if remote_reference?(reference)

    Tap.fetch(reference).name
  rescue Tap::InvalidNameError
    opoo "Invalid tap name in `$#{env_var}`: #{reference}"
    nil
  end.freeze
end

1250
1251
1252
1253
1254
1255
1256
1257
1258

# File 'tap.rb', line 1250

def self.tap_migration_oldnames(current_tap, name_or_token)
  key = "#{current_tap}/#{name_or_token}"

  Tap.each_with_object([]) do |tap, array|
    next unless (renames = tap.reverse_tap_migrations_renames[key])

    array.concat(renames)
  end
end

1394
1395
1396

# File 'tap.rb', line 1394

def self.untapped_official_taps
  Homebrew::Settings.read(:untapped)&.split(";") || []
end

109
110
111
112
113
114
115
116
117
118
119
120
121

# File 'tap.rb', line 109

def self.with_cask_token(token)
  return unless (match = token.match(HOMEBREW_TAP_CASK_REGEX))

  user = T.must(match[:user])
  repository = T.must(match[:repository])
  token = T.must(match[:token])

  # Relative paths are not taps.
  return if [user, repository].intersect?([".", ".."])

  tap = fetch(user, repository)
  [tap, token.downcase]
end

94
95
96
97
98
99
100
101
102
103
104
105
106

# File 'tap.rb', line 94

def self.with_formula_name(name)
  return unless (match = name.match(HOMEBREW_TAP_FORMULA_REGEX))

  user = T.must(match[:user])
  repository = T.must(match[:repository])
  name = T.must(match[:name])

  # Relative paths are not taps.
  return if [user, repository].intersect?([".", ".."])

  tap = fetch(user, repository)
  [tap, name.downcase]
end

1404
1405
1406

# File 'tap.rb', line 1404

def alias_file_to_name(file)
  "#{name}/#{file.basename}"
end

1098
1099
1100

# File 'tap.rb', line 1098

def alias_files
  @alias_files ||= T.let(Pathname.glob("#{alias_dir}/*").select(&:file?), T.nilable(T::Array[Pathname]))
end

1118
1119
1120
1121
1122
1123
1124
1125
1126

# File 'tap.rb', line 1118

def alias_reverse_table
  @alias_reverse_table ||= T.let(
    alias_table.each_with_object({}) do |(alias_name, formula_name), alias_reverse_table|
      alias_reverse_table[formula_name] ||= []
      alias_reverse_table[formula_name] << alias_name
    end,
    T.nilable(T::Hash[String, T::Array[String]]),
  )
end

1110
1111
1112
1113
1114

# File 'tap.rb', line 1110

def alias_table
  @alias_table ||= T.let(alias_files.to_h do |alias_file|
                           [alias_file_to_name(alias_file), formula_file_to_name(alias_file.resolved_path)]
                         end, T.nilable(T::Hash[String, String]))
end

1104
1105
1106

# File 'tap.rb', line 1104

def aliases
  @aliases ||= T.let(alias_table.keys, T.nilable(T::Array[String]))
end

1294
1295
1296

# File 'tap.rb', line 1294

def allow_bump?(formula_or_cask_name)
  ENV["HOMEBREW_TEST_BOT_AUTOBUMP"].present? || !official? || autobump.exclude?(formula_or_cask_name)
end

1432
1433
1434
1435
1436
1437

# File 'tap.rb', line 1432

def allowed_by_env?(remote: self.remote)
  allowed_taps = self.class.allowed_taps

  implicitly_trusted?(remote:) || allowed_taps.blank? ||
    allowed_taps.any? { |reference| matches_reference?(reference, remote:) }
end

549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591

# File 'tap.rb', line 549

def apply_redirected_remote!(redirected_remote, quiet: false)
  old_name = name
  old_remote = remote
  return if old_remote.present? && self.class.same_remote?(old_remote, redirected_remote)

  redirected_reference = self.class.remote_to_reference(redirected_remote)
  if redirected_reference.present? && !self.class.remote_reference?(redirected_reference)
    redirected_tap = Tap.fetch(redirected_reference)
    if redirected_tap.name != name && !redirected_tap.installed?
      old_path = path
      redirected_tap.path.dirname.mkpath
      FileUtils.mv(old_path, redirected_tap.path)
      old_path.parent.rmdir_if_possible

      @user = redirected_tap.user
      @repository = redirected_tap.repository
      @name = redirected_tap.name
      @full_repository = redirected_tap.full_repository
      @full_name = redirected_tap.full_name
      @path = redirected_tap.path
      @git_repository = GitRepository.new(@path)
      clear_cache
    end
  end

  safe_system "git", "-C", path, "remote", "set-url", "origin", redirected_remote
  clear_cache
  Tap.clear_cache

  require "trust"
  trust_invalidated = Homebrew::Trust.invalidate_tap_references!(old_name, remote: old_remote)

  return if quiet

  $stderr.ohai(
    if old_name == name
      "Redirected tap #{name} remote to #{redirected_remote}"
    else
      "Redirected tap #{old_name} to tap #{name}"
    end,
  )
  $stderr.puts "#{trust_invalidated ? "Untrusted" : "Not trusted"} tap: #{old_name}"
end

1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429

# File 'tap.rb', line 1412

def audit_exception(list, formula_or_cask, value = nil)
  return false if audit_exceptions.blank?
  return false unless audit_exceptions.key? list

  list = audit_exceptions[list]

  case list
  when Array
    list.include? formula_or_cask
  when Hash
    return false unless list.include? formula_or_cask
    return list[formula_or_cask] if value.blank?

    return list[formula_or_cask].include?(value) if list[formula_or_cask].is_a?(Array)

    list[formula_or_cask] == value
  end
end

1300
1301
1302
1303

# File 'tap.rb', line 1300

def audit_exceptions
  @audit_exceptions ||= T.let(read_formula_list_directory("#{HOMEBREW_TAP_AUDIT_EXCEPTIONS_DIR}/*"),
                              T.nilable(T::Hash[Symbol, T.untyped]))
end

1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290

# File 'tap.rb', line 1262

def autobump
  autobump_packages = if core_cask_tap?
    Homebrew::API::Cask.all_casks
  elsif core_tap?
    Homebrew::API::Formula.all_formulae
  else
    {}
  end

  @autobump ||= T.let(autobump_packages.select do |_, p|
    next if p["disabled"]
    next if p["skip_livecheck"]

    p["autobump"] == true
  end.keys, T.nilable(T::Array[String]))

  if @autobump.blank?
    @autobump = T.let(
      if (autobump_file = path/HOMEBREW_TAP_AUTOBUMP_FILE).file?
        autobump_file.readlines(chomp: true)
      else
        []
      end,
      T.nilable(T::Array[String]),
    )
  end

  T.must(@autobump)
end

1453
1454
1455

# File 'tap.rb', line 1453

def canonical_remote?(remote = self.remote)
  remote.blank? || self.class.same_remote?(remote, default_remote)
end

941
942
943

# File 'tap.rb', line 941

def cask_dir
  @cask_dir ||= T.let(path/"Casks", T.nilable(Pathname))
end

1064
1065
1066

# File 'tap.rb', line 1064

def cask_file?(file)
  file.match?(CASK_FILE_REGEX)
end

1007
1008
1009
1010
1011
1012
1013
1014
1015
1016

# File 'tap.rb', line 1007

def cask_files
  @cask_files ||= T.let(
    if cask_dir.directory?
      Pathname.glob(cask_dir/"**/*.rb")
    else
      []
    end,
    T.nilable(T::Array[Pathname]),
  )
end

1020
1021
1022
1023
1024
1025
1026
1027

# File 'tap.rb', line 1020

def cask_files_by_name
  @cask_files_by_name ||= T.let(cask_files.each_with_object({}) do |file, hash|
    # If there's more than one file with the same basename: use the longer one to prioritise more specific results.
    basename = file.basename(".rb").to_s
    existing_file = hash[basename]
    hash[basename] = file if existing_file.nil? || existing_file.to_s.length < file.to_s.length
  end, T.nilable(T::Hash[String, Pathname]))
end

1178
1179
1180
1181
1182
1183
1184
1185
1186
1187

# File 'tap.rb', line 1178

def cask_renames
  @cask_renames ||= T.let(
    if (rename_file = path/HOMEBREW_TAP_CASK_RENAMES_FILE).file?
      JSON.parse(rename_file.read)
    else
      {}
    end,
    T.nilable(T::Hash[String, String]),
  )
end

1191
1192
1193
1194
1195
1196

# File 'tap.rb', line 1191

def cask_reverse_renames
  @cask_reverse_renames ||= T.let(cask_renames.each_with_object({}) do |(old_name, new_name), hash|
    hash[new_name] ||= []
    hash[new_name] << old_name
  end, T.nilable(T::Hash[String, T::Array[String]]))
end

1086
1087
1088

# File 'tap.rb', line 1086

def cask_tokens
  @cask_tokens ||= T.let(cask_files.map { formula_file_to_name(it) }, T.nilable(T::Array[String]))
end

310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347

# File 'tap.rb', line 310

def clear_cache
  @remote = nil
  @repository_var_suffix = nil
  remove_instance_variable(:@private) if instance_variable_defined?(:@private)

  @formula_dir = nil
  @formula_files = nil
  @formula_files_by_name = nil
  @formula_names = nil
  @prefix_to_versioned_formulae_names = nil
  @formula_renames = nil
  @formula_reverse_renames = nil

  @cask_dir = nil
  @cask_files = nil
  @cask_files_by_name = nil
  @cask_tokens = nil
  @cask_renames = nil
  @cask_reverse_renames = nil

  @alias_dir = nil
  @alias_files = nil
  @aliases = nil
  @alias_table = nil
  @alias_reverse_table = nil

  @command_dir = nil
  @command_files = nil

  @tap_migrations = nil
  @reverse_tap_migrations_renames = nil

  @audit_exceptions = nil
  @style_exceptions = nil
  @synced_versions_formulae = nil

  @config = nil
end

1129
1130
1131

# File 'tap.rb', line 1129

def command_dir
  @command_dir ||= T.let(path/"cmd", T.nilable(Pathname))
end

1135
1136
1137
1138
1139
1140
1141
1142
1143
1144

# File 'tap.rb', line 1135

def command_files
  @command_files ||= T.let(
    if command_dir.directory?
      Commands.find_commands(command_dir)
    else
      []
    end,
    T.nilable(T::Array[Pathname]),
  )
end

506
507
508
509
510
511
512

# File 'tap.rb', line 506

def config
  @config ||= T.let(begin
    raise TapUnavailableError, name unless installed?

    TapConfig.new(self)
  end, T.nilable(TapConfig))
end

957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973

# File 'tap.rb', line 957

def contents
  contents = []

  if (command_count = command_files.count).positive?
    contents << Utils.pluralize("command", command_count, include_count: true)
  end

  if (cask_count = cask_files.count).positive?
    contents << Utils.pluralize("cask", cask_count, include_count: true)
  end

  if (formula_count = formula_files.count).positive?
    contents << Utils.pluralize("formula", formula_count, include_count: true)
  end

  contents
end

534
535
536

# File 'tap.rb', line 534

def core_cask_tap?
  false
end

529
530
531

# File 'tap.rb', line 529

def core_tap?
  false
end

876
877
878
879
880

# File 'tap.rb', line 876

def custom_remote?
  return true unless (remote = self.remote)

  !self.class.same_remote?(remote, default_remote)
end

411
412
413

# File 'tap.rb', line 411

def default_remote
  "https://github.com/#{full_name}"
end

1327
1328
1329
1330
1331
1332
1333
1334
1335
1336

# File 'tap.rb', line 1327

def disabled_new_usr_local_relocation_formulae
  @disabled_new_usr_local_relocation_formulae ||= T.let(
    if (synced_file = path/HOMEBREW_TAP_DISABLED_NEW_USR_LOCAL_RELOCATION_FORMULAE_FILE).file?
      JSON.parse(synced_file.read)
    else
      []
    end,
    T.nilable(T::Array[String]),
  )
end

380
381
382
383
384

# File 'tap.rb', line 380

def ensure_installed!
  return if installed?

  install
end

790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824

# File 'tap.rb', line 790

def fix_remote_configuration(requested_remote: nil, quiet: false)
  if requested_remote.present?
    path.cd do
      safe_system "git", "remote", "set-url", "origin", requested_remote
      safe_system "git", "config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"
    end
    $stderr.ohai "#{name}: changed remote from #{remote} to #{requested_remote}" unless quiet
  end
  return unless remote

  current_upstream_head = git_repository.origin_branch_name
  return if current_upstream_head.present? && requested_remote.blank? &&
            git_repository.origin_has_branch?(current_upstream_head)

  args = %w[fetch]
  args << "--quiet" if quiet
  args << "origin"
  args << "+refs/heads/*:refs/remotes/origin/*"
  result = git_command!(args, chdir: path)
  update_remote_from_git_redirect!(result.stderr, quiet:)
  git_repository.set_head_origin_auto

  current_upstream_head ||= T.must(git_repository.origin_branch_name)

  new_upstream_head = T.must(git_repository.origin_branch_name)
  return if new_upstream_head == current_upstream_head

  safe_system "git", "-C", path, "config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"
  git_repository.rename_branch old: current_upstream_head, new: new_upstream_head
  git_repository.set_upstream_branch local: new_upstream_head, origin: new_upstream_head

  return if quiet

  $stderr.ohai "#{name}: changed default branch name from #{current_upstream_head} to #{new_upstream_head}!"
end

1440
1441
1442

# File 'tap.rb', line 1440

def forbidden_by_env?(remote: self.remote)
  self.class.forbidden_taps.any? { |reference| matches_reference?(reference, remote:) }
end

915
916
917
918
919
920
921
922
923
924
925

# File 'tap.rb', line 915

def formula_dir
  # Official formulae taps always use this directory, saves time to hardcode.
  @formula_dir ||= T.let(
    if official?
      path/"Formula"
    else
      potential_formula_dirs.find(&:directory?) || (path/"Formula")
    end,
    T.nilable(Pathname),
  )
end

1055
1056
1057

# File 'tap.rb', line 1055

def formula_file?(file)
  file.match?(formula_file_regex)
end

1399
1400
1401

# File 'tap.rb', line 1399

def formula_file_to_name(file)
  "#{name}/#{file.basename(".rb")}"
end

977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992

# File 'tap.rb', line 977

def formula_files
  @formula_files ||= T.let(
    if formula_dir.directory?
      if formula_dir == path
        # We only want the top level here so we don't treat commands & casks as formulae.
        # Sharding is only supported in Formula/ and HomebrewFormula/.
        Pathname.glob(formula_dir/"*.rb")
      else
        Pathname.glob(formula_dir/"**/*.rb")
      end
    else
      []
    end,
    T.nilable(T::Array[Pathname]),
  )
end

996
997
998
999
1000
1001
1002
1003

# File 'tap.rb', line 996

def formula_files_by_name
  @formula_files_by_name ||= T.let(formula_files.each_with_object({}) do |file, hash|
    # If there's more than one file with the same basename: use the longer one to prioritise more specific results.
    basename = file.basename(".rb").to_s
    existing_file = hash[basename]
    hash[basename] = file if existing_file.nil? || existing_file.to_s.length < file.to_s.length
  end, T.nilable(T::Hash[String, Pathname]))
end

1070
1071
1072

# File 'tap.rb', line 1070

def formula_names
  @formula_names ||= T.let(formula_files.map { formula_file_to_name(it) }, T.nilable(T::Array[String]))
end

1200
1201
1202
1203
1204
1205
1206
1207
1208
1209

# File 'tap.rb', line 1200

def formula_renames
  @formula_renames ||= T.let(
    if (rename_file = path/HOMEBREW_TAP_FORMULA_RENAMES_FILE).file?
      JSON.parse(rename_file.read)
    else
      {}
    end,
    T.nilable(T::Hash[String, String]),
  )
end

1213
1214
1215
1216
1217
1218

# File 'tap.rb', line 1213

def formula_reverse_renames
  @formula_reverse_renames ||= T.let(formula_renames.each_with_object({}) do |(old_name, new_name), hash|
    hash[new_name] ||= []
    hash[new_name] << old_name
  end, T.nilable(T::Hash[String, T::Array[String]]))
end

427
428
429

# File 'tap.rb', line 427

def git?
  git_repository.git_repository?
end

435
436
437
438
439

# File 'tap.rb', line 435

def git_branch
  raise TapUnavailableError, name unless installed?

  git_repository.branch_name
end

445
446
447
448
449

# File 'tap.rb', line 445

def git_head
  raise TapUnavailableError, name unless installed?

  @git_head ||= T.let(git_repository.head_ref, T.nilable(String))
end

455
456
457
458
459

# File 'tap.rb', line 455

def git_last_commit
  raise TapUnavailableError, name unless installed?

  git_repository.last_committed
end

1448
1449
1450

# File 'tap.rb', line 1448

def implicitly_trusted?(remote: self.remote)
  official? && canonical_remote?(remote)
end

619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771

# File 'tap.rb', line 619

def install(quiet: false, clone_target: nil,
            custom_remote: false, verify: false, force: false)
  require "descriptions"
  require "readall"

  if official? && DEPRECATED_OFFICIAL_TAPS.include?(repository)
    odie "#{name} was deprecated. This tap is now empty and all its contents were either deleted or migrated."
  elsif user == "caskroom" || name == "phinze/cask"
    new_repository = (repository == "cask") ? "cask" : "cask-#{repository}"
    odie "#{name} was moved. Tap homebrew/#{new_repository} instead."
  end

  raise TapNoCustomRemoteError, name if custom_remote && clone_target.nil?

  requested_remote = (clone_target || default_remote).to_s

  if installed? && !custom_remote
    raise TapRemoteMismatchError.new(name, @remote, requested_remote) if clone_target && requested_remote != remote
    raise TapAlreadyTappedError, name unless shallow?
  end

  tap_allowed = allowed_by_env?(remote: requested_remote)
  tap_forbidden = forbidden_by_env?(remote: requested_remote)
  if !tap_allowed || tap_forbidden
    owner = Homebrew::EnvConfig.forbidden_owner
    owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
      "\n#{contact}"
    end

    error_message = "The installation of the #{full_name} was requested but #{owner}\n"
    error_message << "has not allowed this tap in `$HOMEBREW_ALLOWED_TAPS`" unless tap_allowed
    error_message << " and\n" if !tap_allowed && tap_forbidden
    error_message << "has forbidden this tap in `$HOMEBREW_FORBIDDEN_TAPS`" if tap_forbidden
    error_message << ".#{owner_contact}"

    odie error_message
  end

  # ensure git is installed
  Utils::Git.ensure_installed!

  use_worktree_source_tap = core_tap? || (core_cask_tap? && clone_target.nil? && !custom_remote)
  worktree_source_tap_path = use_worktree_source_tap ? worktree_source_tap_path_for(path: HOMEBREW_REPOSITORY) : nil

  if installed?
    if requested_remote != remote # we are sure that clone_target is not nil and custom_remote is true here
      fix_remote_configuration(requested_remote:, quiet:)
    end

    config.delete(:forceautoupdate)

    $stderr.ohai "Unshallowing #{name}" if shallow? && !quiet
    args = %w[fetch]
    # Git throws an error when attempting to unshallow a full clone
    args << "--unshallow" if shallow?
    args << "-q" if quiet
    result = git_command!(args, chdir: path)
    update_remote_from_git_redirect!(result.stderr, quiet:)
    return
  elsif (core_tap? || core_cask_tap?) && !Homebrew::EnvConfig.no_install_from_api? && !force &&
        worktree_source_tap_path.blank?
    odie "Tapping #{name} is no longer typically necessary.\n" \
         "Add #{Formatter.option("--force")} if you are sure you need it for contributing to Homebrew."
  end

  clear_cache
  Tap.clear_cache

  $stderr.ohai "Tapping #{name}" unless quiet
  args = %W[clone#{requested_remote}#{path}]

  # Override possible user configs like:
  #   git config --global clone.defaultRemoteName notorigin
  args << "--origin=origin"
  args << "-q" if quiet

  # Override user-set default template.
  args << "--template="
  # Prevent `fsmonitor` from watching this repository.
  args << "--config" << "core.fsmonitor=false"

  begin
    if worktree_source_tap_path
      # Keep core and cask taps connected to the same local source checkout as brew.
      worktree_args = ["-C", worktree_source_tap_path, "worktree", "add"]
      worktree_args << "--quiet" if quiet
      worktree_args += ["--detach", path, "HEAD"]
      safe_system "git", *worktree_args
    else
      result = git_command!(args)
      update_remote_from_git_redirect!(result.stderr, quiet:)
    end

    if verify && !Homebrew::EnvConfig.developer? && !Readall.valid_tap?(self, aliases: true)
      raise "Cannot tap #{name}: invalid syntax in tap!"
    end
  rescue Interrupt, RuntimeError
    ignore_interrupts do
      # wait for git to possibly cleanup the top directory when interrupt happens.
      sleep 0.1
      FileUtils.rm_rf path
      path.parent.rmdir_if_possible
    end
    raise
  end

  Commands.rebuild_commands_completion_list
  link_completions_and_manpages

  formatted_contents = contents.presence&.to_sentence&.prepend("")
  $stderr.puts "Tapped#{formatted_contents} (#{path.abv})." unless quiet

  require "description_cache_store"
  if formula_names.present?
    CacheStoreDatabase.use(:descriptions) do |db|
      DescriptionCacheStore.new(T.cast(db, CacheStoreDatabase[String, T.anything]))
                           .update_from_formula_names!(formula_names)
    end
  end
  if cask_tokens.present?
    CacheStoreDatabase.use(:cask_descriptions) do |db|
      CaskDescriptionCacheStore.new(T.cast(db, CacheStoreDatabase[String, T.anything]))
                               .update_from_cask_tokens!(cask_tokens)
    end
  end

  if official?
    untapped = self.class.untapped_official_taps
    untapped -= [name]

    if untapped.empty?
      Homebrew::Settings.delete :untapped
    else
      Homebrew::Settings.write :untapped, untapped.join(";")
    end
  end

  return if clone_target
  return unless private?
  return if quiet

  path.cd do
    return if Utils.popen_read("git", "config", "--get", "credential.helper").present?
  end

  $stderr.puts <<~EOS
    It looks like you tapped a private repository. To avoid entering your
    credentials each time you update, you can use git HTTP credential
    caching or issue the following command:
      cd #{path}      git remote set-url origin git@github.com:#{full_name}.git
  EOS
end