Module: Utils::Path Private

112
113
114

# File 'utils/path.rb', line 112

def self.formula_any_version_installed?(formula_names)
  formula_installed_prefixes(formula_names).any? { |keg| (keg/"INSTALL_RECEIPT.json").file? }
end

101
102
103
104
105
106

# File 'utils/path.rb', line 101

def self.formula_installed_prefixes(formula_names)
  Array(formula_names).map { |formula_name| HOMEBREW_CELLAR/Utils.name_from_full_name(formula_name) }
                      .select(&:directory?)
                      .flat_map(&:subdirs)
                      .sort_by(&:basename)
end

37
38
39

# File 'utils/path.rb', line 37

def self.formula_opt_bin(formula_name)
  formula_opt_prefix(formula_name)/"bin"
end

136
137
138

# File 'utils/path.rb', line 136

def self.formula_opt_bin_env(formula_name, *paths)
  { "PATH" => formula_opt_bin_path(formula_name, *paths).to_s }
end

128
129
130

# File 'utils/path.rb', line 128

def self.formula_opt_bin_path(formula_name, *paths)
  PATH.new(formula_opt_bin(formula_name), *paths, ENV.fetch("PATH"))
end

85
86
87

# File 'utils/path.rb', line 85

def self.formula_opt_include(formula_name)
  formula_opt_prefix(formula_name)/"include"
end

53
54
55

# File 'utils/path.rb', line 53

def self.formula_opt_lib(formula_name)
  formula_opt_prefix(formula_name)/"lib"
end

69
70
71

# File 'utils/path.rb', line 69

def self.formula_opt_libexec(formula_name)
  formula_opt_prefix(formula_name)/"libexec"
end

21
22
23

# File 'utils/path.rb', line 21

def self.formula_opt_prefix(formula_name)
  HOMEBREW_PREFIX/"opt/#{Utils.name_from_full_name(formula_name)}"
end

141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

# File 'utils/path.rb', line 141

def self.loadable_package_path?(path, package_type)
  return true unless Homebrew::EnvConfig.forbid_packages_from_paths?

  path_realpath = path.realpath.to_s
  path_string = path.to_s

  allowed_paths = [trusted_package_root("#{HOMEBREW_LIBRARY}/Taps/")]
  allowed_paths << if package_type == :formula
    trusted_package_root(HOMEBREW_CELLAR)
  else
    trusted_package_root(Cask::Caskroom.path)
  end

  # Casks can also be loaded from local JSON files, not just Ruby.
  package_extnames = (package_type == :cask) ? %w[.rb.json] : %w[.rb]
  return true if package_extnames.none? { |ext| path_realpath.end_with?(ext) || path_string.end_with?(ext) }

  # Compare path ancestry, not string prefixes, so `..` can't escape a trusted root.
  return true if allowed_paths.any? { |root| child_of?(root, path_realpath) }
  return true if allowed_paths.any? { |root| child_of?(root, path) }

  # Looks like a local path, Ruby file and not a tap.
  if path_string.include?("./") || path_string.end_with?(".rb") || path_string.count("/") != 2
    package_type_plural = Utils.pluralize(package_type.to_s, 2)
    path_realpath_if_different = " (#{path_realpath})" if path_realpath != path_string
    create_flag = " --cask" if package_type == :cask

    raise <<~WARNING
      Homebrew requires #{package_type_plural} to be in a tap, rejecting:
#{path_string}#{path_realpath_if_different}      To create a tap, run e.g.
        brew tap-new <user|org>/<repository>
      To create a #{package_type} in a tap run e.g.
        brew create#{create_flag} <url> --tap=<user|org>/<repository>
    WARNING
  else
    # Looks like a tap, let's quietly reject but not error.
    path_string.count("/") != 2
  end
end

45
46
47

# File 'utils/path.rb', line 45

def formula_opt_bin(formula_name)
  Utils::Path.formula_opt_bin(formula_name)
end

93
94
95

# File 'utils/path.rb', line 93

def formula_opt_include(formula_name)
  Utils::Path.formula_opt_include(formula_name)
end

61
62
63

# File 'utils/path.rb', line 61

def formula_opt_lib(formula_name)
  Utils::Path.formula_opt_lib(formula_name)
end

77
78
79

# File 'utils/path.rb', line 77

def formula_opt_libexec(formula_name)
  Utils::Path.formula_opt_libexec(formula_name)
end

29
30
31

# File 'utils/path.rb', line 29

def formula_opt_prefix(formula_name)
  Utils::Path.formula_opt_prefix(formula_name)
end