Класс: Pathname Закрытый

433
434
435

# File 'extend/pathname.rb', line 433

def arch_compatible?(_wanted_arch)
  true
end

111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

# File 'extend/pathname.rb', line 111

def atomic_write(content)
  require "extend/file/atomic"

  old_stat = stat if exist?
  File.atomic_write(self) do |file|
    file.write(content)
  end

  return unless old_stat

  # Try to restore original file's permissions separately
  # atomic_write does it itself, but it actually erases
  # them if chown fails
  begin
    # Set correct permissions on new file
    chown(old_stat.uid, nil)
    chown(nil, old_stat.gid)
  rescue Errno::EPERM, Errno::EACCES
    # Changing file ownership failed, moving on.
    nil
  end

  begin
    # This operation will affect filesystem ACL's
    chmod(old_stat.mode)
  rescue Errno::EPERM, Errno::EACCES
    # Changing file permissions failed, moving on.
    nil
  end
end

418
419
420

# File 'extend/pathname.rb', line 418

def binary_executable?
  false
end

244
245
246

# File 'extend/pathname.rb', line 244

def cd(&_block)
  Dir.chdir(self) { yield self }
end

146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

# File 'extend/pathname.rb', line 146

def cp_path_sub(pattern, replacement, &_block)
  raise "#{self} does not exist" unless exist?

  pattern = pattern.to_s if pattern.is_a?(Pathname)
  replacement = replacement.to_s if replacement.is_a?(Pathname)
  dst = sub(pattern, replacement)

  raise "#{self} is the same file as #{dst}" if self == dst

  if directory?
    dst.mkpath
  else
    dst.dirname.mkpath
    dst = yield(self, dst) if block_given?
    FileUtils.cp(self, dst)
  end
end

413
414
415

# File 'extend/pathname.rb', line 413

def ds_store?
  basename.to_s == ".DS_Store"
end

428
429
430

# File 'extend/pathname.rb', line 428

def dylib?
  false
end

278
279
280
281
282
283
284
285
286
287

# File 'extend/pathname.rb', line 278

def ensure_writable(&_block)
  saved_perms = nil
  unless writable?
    saved_perms = stat.mode
    FileUtils.chmod "u+rw", to_path
  end
  yield
ensure
  chmod saved_perms if saved_perms
end

359
360
361
362
363
364
365
366
367
368
369
370

# File 'extend/pathname.rb', line 359

def env_script_all_files(dst, env)
  dst.mkpath
  Pathname.glob("#{self}/*") do |file|
    next if file.directory?

    new_file = dst.join(file.basename)
    raise Errno::EEXIST, new_file.to_s if new_file.exist?

    dst.install(file)
    file.write_env_script(new_file, env)
  end
end

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

# File 'extend/pathname.rb', line 168

def extname
  basename = File.basename(self)

  bottle_ext, = HOMEBREW_BOTTLES_EXTNAME_REGEX.match(basename).to_a
  return bottle_ext if bottle_ext

  archive_ext = basename[/(\.(tar|cpio|pax)\.(gz|bz2|lz|xz|zst|Z))\Z/, 1]
  return archive_ext if archive_ext

  # Don't treat version numbers as extname.
  return "" if basename.match?(/\b\d+\.\d+[^.]*\Z/) && !basename.end_with?(".7z")

  File.extname(basename)
end

455
456
457
458
459

# File 'extend/pathname.rb', line 455

def file_type
  @file_type ||= T.let(nil, T.nilable(String))
  @file_type ||= system_command("file", args: ["-b", self], print_stderr: false)
                 .stdout.chomp
end

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# File 'extend/pathname.rb', line 49

def install(*sources)
  sources.each do |src|
    case src
    when Resource
      src.stage(self)
    when Resource::Partial
      src.resource.stage { install(*src.files) }
    when Array
      if src.empty?
        opoo "Tried to install empty array to #{self}"
        break
      end
      src.each { |s| install_p(s, File.basename(s)) }
    when Hash
      if src.empty?
        opoo "Tried to install empty hash to #{self}"
        break
      end
      src.each { |s, new_basename| install_p(s, new_basename) }
    else
      install_p(src, File.basename(src))
    end
  end
end

290
291
292

# File 'extend/pathname.rb', line 290

def install_info
  quiet_system(which_install_info, "--quiet", to_s, "#{dirname}/dir")
end

393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410

# File 'extend/pathname.rb', line 393

def install_metafiles(from = Pathname.pwd)
  require "metafiles"

  Pathname(from).children.each do |p|
    next if p.directory?
    next if File.empty?(p)
    next unless Metafiles.copy?(p.basename.to_s)

    # Some software symlinks these files (see help2man.rb)
    filename = p.resolved_path
    # Some software links metafiles together, so by the time we iterate to one of them
    # we may have already moved it. libxml2's COPYING and Copyright are affected by this.
    next unless filename.exist?

    filename.chmod 0644
    install(filename)
  end
end

82
83
84
85
86
87
88
89
90
91
92
93

# File 'extend/pathname.rb', line 82

def install_symlink(*sources)
  sources.each do |src|
    case src
    when Array
      src.each { |s| install_symlink_p(s, File.basename(s)) }
    when Hash
      src.each { |s, new_basename| install_symlink_p(s, new_basename) }
    else
      install_symlink_p(src, File.basename(src))
    end
  end
end

423
424
425

# File 'extend/pathname.rb', line 423

def mach_o_bundle?
  false
end

443
444
445
446
447
448
449
450
451
452

# File 'extend/pathname.rb', line 443

def magic_number
  @magic_number ||= T.let(nil, T.nilable(String))
  @magic_number ||= if directory?
    ""
  else
    # Length of the longest regex (currently Tar).
    max_magic_number_length = 262
    binread(max_magic_number_length) || ""
  end
end

272
273
274
275

# File 'extend/pathname.rb', line 272

def make_relative_symlink(src)
  dirname.mkpath
  File.symlink(src.relative_path_from(dirname), self)
end

257
258
259

# File 'extend/pathname.rb', line 257

def resolved_path
  symlink? ? dirname.join(readlink) : self
end

262
263
264
265
266
267
268
269

# File 'extend/pathname.rb', line 262

def resolved_path_exists?
  link = readlink
rescue ArgumentError
  # The link target contains NUL bytes
  false
else
  dirname.join(link).exist?
end

195
196
197
198
199
200
201
202
203
204
205
206
207

# File 'extend/pathname.rb', line 195

def rmdir_if_possible
  rmdir
  true
rescue Errno::ENOTEMPTY
  if (ds_store = join(".DS_Store")).exist? && children.length == 1
    ds_store.unlink
    retry
  else
    false
  end
rescue Errno::EACCES, Errno::ENOENT, Errno::EBUSY, Errno::EPERM
  false
end

438
439
440

# File 'extend/pathname.rb', line 438

def rpaths
  []
end

221
222
223
224

# File 'extend/pathname.rb', line 221

def sha256
  require "digest/sha2"
  Digest::SHA256.file(self).hexdigest
end

187
188
189

# File 'extend/pathname.rb', line 187

def stem
  File.basename(self, extname)
end

252
253
254

# File 'extend/pathname.rb', line 252

def subdirs
  children.select(&:directory?)
end

216
217
218

# File 'extend/pathname.rb', line 216

def text_executable?
  /\A#!\s*\S+/.match?(open("r") { |f| f.read(1024) })
end

295
296
297

# File 'extend/pathname.rb', line 295

def uninstall_info
  quiet_system(which_install_info, "--delete", "--quiet", to_s, "#{dirname}/dir")
end

227
228
229
230
231
232

# File 'extend/pathname.rb', line 227

def verify_checksum(expected)
  raise ChecksumMissingError if expected.blank?

  actual = Checksum.new(sha256.downcase)
  raise ChecksumMismatchError.new(self, expected, actual) if expected != actual
end

210
211
212
213

# File 'extend/pathname.rb', line 210

def version
  require "version"
  Version.parse(basename)
end

333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353

# File 'extend/pathname.rb', line 333

def write_env_script(target, args_or_env, env = T.unsafe(nil))
  args = if env.nil?
    env = args_or_env if args_or_env.is_a?(Hash)

    nil
  elsif args_or_env.is_a?(Array)
    args_or_env.join("")
  else
    T.cast(args_or_env, T.nilable(T.any(String, Pathname)))
  end

  env_export = +""
  env.each { |key, value| env_export << "#{key}=\"#{value}\" " }

  dirname.mkpath

  write <<~SH
    #!/bin/bash
#{env_export}exec "#{target}" #{args} "$@"
  SH
end

303
304
305
306
307
308
309
310
311
312
313
314
315
316
317

# File 'extend/pathname.rb', line 303

def write_exec_script(*targets)
  targets.flatten!
  if targets.empty?
    opoo "Tried to write exec scripts to #{self} for an empty list of targets"
    return
  end
  mkpath
  targets.each do |target|
    target = Pathname.new(target) # allow pathnames or strings
    join(target.basename).write <<~SH
      #!/bin/bash
      exec "#{target}" "$@"
    SH
  end
end

383
384
385
386
387
388
389
390

# File 'extend/pathname.rb', line 383

def write_jar_script(target_jar, script_name, java_opts = "", java_version: nil)
  mkpath
  (self/script_name).write <<~EOS
    #!/bin/bash
    export JAVA_HOME="#{Language::Java.overridable_java_home_env(java_version)[:JAVA_HOME]}"
    exec "${JAVA_HOME}/bin/java" #{java_opts} -jar "#{target_jar}" "$@"
  EOS
end

462
463
464
465
466
467
468
469
470

# File 'extend/pathname.rb', line 462

def zipinfo
  @zipinfo ||= T.let(
    system_command("zipinfo", args: ["-1", self], print_stderr: false)
    .stdout
    .encode(Encoding::UTF_8, invalid: :replace)
    .split("\n"),
    T.nilable(T::Array[String]),
  )
end