Class: Zip::FileSystem::ZipFsFile

Inherits:
Object
  • Object
show all
Defined in:
lib/zip/filesystem.rb

Overview

Instances of this class are normally accessed via the accessor Zip::File::file. An instance of ZipFsFile behaves like ruby’s builtin File (class) object, except it works on Zip::File entries.

The individual methods are not documented due to their similarity with the methods in File

Defined Under Namespace

Classes: ZipFsStat

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(mapped_zip) ⇒ ZipFsFile

Returns a new instance of ZipFsFile.



171
172
173
 
# File 'lib/zip/filesystem.rb', line 171

def initialize(mapped_zip)
  @mapped_zip = mapped_zip
end

Instance Attribute Details

#dir=(value) ⇒ Object (writeonly)

Sets the attribute dir

Parameters:

  • value —

    the value to set the attribute dir to.



66
67
68
 
# File 'lib/zip/filesystem.rb', line 66

def dir=(value)
  @dir = value
end

Instance Method Details

#atime(filename) ⇒ Object 



326
327
328
329
330
331
332
333
 
# File 'lib/zip/filesystem.rb', line 326

def atime(filename)
  e = get_entry(filename)
  if e.extra.member? 'UniversalTime'
    e.extra['UniversalTime'].atime
  elsif e.extra.member? 'NTFS'
    e.extra['NTFS'].atime
  end
end

#basename(filename) ⇒ Object 



304
305
306
 
# File 'lib/zip/filesystem.rb', line 304

def basename(filename)
  ::File.basename(filename)
end

#blockdev?(_filename) ⇒ Boolean

Returns:

  • (Boolean) 


348
349
350
 
# File 'lib/zip/filesystem.rb', line 348

def blockdev?(_filename)
  false
end

#chardev?(_filename) ⇒ Boolean

Returns:

  • (Boolean) 


352
353
354
 
# File 'lib/zip/filesystem.rb', line 352

def chardev?(_filename)
  false
end

#chmod(mode, *filenames) ⇒ Object 



277
278
279
280
281
282
283
284
285
286
 
# File 'lib/zip/filesystem.rb', line 277

def chmod(mode, *filenames)
  filenames.each do |filename|
    e = get_entry(filename)
    e.fstype = 3 # force convertion filesystem type to unix
    e.unix_perms = mode
    e.external_file_attributes = mode << 16
    e.dirty = true
  end
  filenames.size
end

#chown(owner, group, *filenames) ⇒ Object 



267
268
269
270
271
272
273
274
275
 
# File 'lib/zip/filesystem.rb', line 267

def chown(owner, group, *filenames)
  filenames.each do |filename|
    e = get_entry(filename)
    e.extra.create('IUnix') unless e.extra.member?('IUnix')
    e.extra['IUnix'].uid = owner
    e.extra['IUnix'].gid = group
  end
  filenames.size
end

#ctime(filename) ⇒ Object 



335
336
337
338
339
340
341
342
 
# File 'lib/zip/filesystem.rb', line 335

def ctime(filename)
  e = get_entry(filename)
  if e.extra.member? 'UniversalTime'
    e.extra['UniversalTime'].ctime
  elsif e.extra.member? 'NTFS'
    e.extra['NTFS'].ctime
  end
end

#delete(*args) ⇒ Object Also known as: unlink 



408
409
410
411
412
413
414
415
416
 
# File 'lib/zip/filesystem.rb', line 408

def delete(*args)
  args.each do |filename|
    if directory?(filename)
      raise Errno::EISDIR, "Is a directory - \"#{filename}\""
    end

    @mapped_zip.remove(filename)
  end
end

#directory?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


236
237
238
239
 
# File 'lib/zip/filesystem.rb', line 236

def directory?(filename)
  entry = @mapped_zip.find_entry(filename)
  expand_path(filename) == '/' || (!entry.nil? && entry.directory?)
end

#dirname(filename) ⇒ Object 



300
301
302
 
# File 'lib/zip/filesystem.rb', line 300

def dirname(filename)
  ::File.dirname(filename)
end

#executable?(filename) ⇒ Boolean Also known as: executable_real?

Returns:

  • (Boolean) 


211
212
213
 
# File 'lib/zip/filesystem.rb', line 211

def executable?(filename)
  unix_mode_cmp(filename, 0o111)
end

#exists?(filename) ⇒ Boolean Also known as: exist?, owned?, grpowned?

Returns:

  • (Boolean) 


192
193
194
 
# File 'lib/zip/filesystem.rb', line 192

def exists?(filename)
  expand_path(filename) == '/' || !@mapped_zip.find_entry(filename).nil?
end

#expand_path(path) ⇒ Object 



424
425
426
 
# File 'lib/zip/filesystem.rb', line 424

def expand_path(path)
  @mapped_zip.expand_path(path)
end

#file?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


295
296
297
298
 
# File 'lib/zip/filesystem.rb', line 295

def file?(filename)
  entry = @mapped_zip.find_entry(filename)
  !entry.nil? && entry.file?
end

#foreach(filename, sep = $INPUT_RECORD_SEPARATOR, &a_proc) ⇒ Object 



404
405
406
 
# File 'lib/zip/filesystem.rb', line 404

def foreach(filename, sep = $INPUT_RECORD_SEPARATOR, &a_proc)
  self.open(filename) { |is| is.each_line(sep, &a_proc) }
end

#ftype(filename) ⇒ Object 



364
365
366
 
# File 'lib/zip/filesystem.rb', line 364

def ftype(filename)
  @mapped_zip.get_entry(filename).directory? ? 'directory' : 'file'
end

#join(*fragments) ⇒ Object 



312
313
314
 
# File 'lib/zip/filesystem.rb', line 312

def join(*fragments)
  ::File.join(*fragments)
end

#link(_filename, _symlink_name) ⇒ Object

Raises:

  • (NotImplementedError) 


376
377
378
 
# File 'lib/zip/filesystem.rb', line 376

def link(_filename, _symlink_name)
  raise NotImplementedError, 'The link() function is not implemented'
end

#mtime(filename) ⇒ Object 



322
323
324
 
# File 'lib/zip/filesystem.rb', line 322

def mtime(filename)
  @mapped_zip.get_entry(filename).mtime
end

#new(filename, mode = 'r') ⇒ Object 



253
254
255
 
# File 'lib/zip/filesystem.rb', line 253

def new(filename, mode = 'r')
  self.open(filename, mode)
end

#open(filename, mode = 'r', permissions = 0o644, &block) ⇒ Object 



241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/zip/filesystem.rb', line 241

def open(filename, mode = 'r', permissions = 0o644, &block)
  mode.delete!('b') # ignore b option
  case mode
  when 'r'
    @mapped_zip.get_input_stream(filename, &block)
  when 'w'
    @mapped_zip.get_output_stream(filename, permissions, &block)
  else
    raise StandardError, "openmode '#{mode} not supported" unless mode == 'r'
  end
end

#pipe ⇒ Object

Raises:

  • (NotImplementedError) 


380
381
382
 
# File 'lib/zip/filesystem.rb', line 380

def pipe
  raise NotImplementedError, 'The pipe() function is not implemented'
end

#pipe?(_filename) ⇒ Boolean

Returns:

  • (Boolean) 


344
345
346
 
# File 'lib/zip/filesystem.rb', line 344

def pipe?(_filename)
  false
end

#popen(*args, &a_proc) ⇒ Object 



400
401
402
 
# File 'lib/zip/filesystem.rb', line 400

def popen(*args, &a_proc)
  ::File.popen(*args, &a_proc)
end

#read(filename) ⇒ Object 



396
397
398
 
# File 'lib/zip/filesystem.rb', line 396

def read(filename)
  @mapped_zip.read(filename)
end

#readable?(filename) ⇒ Boolean Also known as: readable_real?

Returns:

  • (Boolean) 


201
202
203
 
# File 'lib/zip/filesystem.rb', line 201

def readable?(filename)
  unix_mode_cmp(filename, 0o444)
end

#readlines(filename) ⇒ Object 



392
393
394
 
# File 'lib/zip/filesystem.rb', line 392

def readlines(filename)
  self.open(filename, &:readlines)
end

#readlink(_filename) ⇒ Object

Raises:

  • (NotImplementedError) 


368
369
370
 
# File 'lib/zip/filesystem.rb', line 368

def readlink(_filename)
  raise NotImplementedError, 'The readlink() function is not implemented'
end

#rename(file_to_rename, new_name) ⇒ Object 



418
419
420
 
# File 'lib/zip/filesystem.rb', line 418

def rename(file_to_rename, new_name)
  @mapped_zip.rename(file_to_rename, new_name) { true }
end

#setgid?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/zip/filesystem.rb', line 220

def setgid?(filename)
  unix_mode_cmp(filename, 0o2000)
end

#setuid?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


216
217
218
 
# File 'lib/zip/filesystem.rb', line 216

def setuid?(filename)
  unix_mode_cmp(filename, 0o4000)
end

#size(filename) ⇒ Object 



257
258
259
 
# File 'lib/zip/filesystem.rb', line 257

def size(filename)
  @mapped_zip.get_entry(filename).size
end

#size?(filename) ⇒ Boolean

Returns nil for not found and nil for directories

Returns:

  • (Boolean) 


262
263
264
265
 
# File 'lib/zip/filesystem.rb', line 262

def size?(filename)
  entry = @mapped_zip.find_entry(filename)
  entry.nil? || entry.directory? ? nil : entry.size
end

#socket?(_filename) ⇒ Boolean

Returns:

  • (Boolean) 


360
361
362
 
# File 'lib/zip/filesystem.rb', line 360

def socket?(_filename)
  false
end

#split(filename) ⇒ Object 



308
309
310
 
# File 'lib/zip/filesystem.rb', line 308

def split(filename)
  ::File.split(filename)
end

#stat(filename) ⇒ Object Also known as: lstat

Raises:

  • (Errno::ENOENT) 


384
385
386
387
388
 
# File 'lib/zip/filesystem.rb', line 384

def stat(filename)
  raise Errno::ENOENT, filename unless exists?(filename)

  ZipFsStat.new(self, filename)
end

#sticky?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


224
225
226
 
# File 'lib/zip/filesystem.rb', line 224

def sticky?(filename)
  unix_mode_cmp(filename, 0o1000)
end

#symlink(_filename, _symlink_name) ⇒ Object

Raises:

  • (NotImplementedError) 


372
373
374
 
# File 'lib/zip/filesystem.rb', line 372

def symlink(_filename, _symlink_name)
  raise NotImplementedError, 'The symlink() function is not implemented'
end

#symlink?(_filename) ⇒ Boolean

Returns:

  • (Boolean) 


356
357
358
 
# File 'lib/zip/filesystem.rb', line 356

def symlink?(_filename)
  false
end

#truncate(_filename, _len) ⇒ Object

Raises:

  • (StandardError) 


232
233
234
 
# File 'lib/zip/filesystem.rb', line 232

def truncate(_filename, _len)
  raise StandardError, 'truncate not supported'
end

#umask(*args) ⇒ Object 



228
229
230
 
# File 'lib/zip/filesystem.rb', line 228

def umask(*args)
  ::File.umask(*args)
end

#utime(modified_time, *filenames) ⇒ Object 



316
317
318
319
320
 
# File 'lib/zip/filesystem.rb', line 316

def utime(modified_time, *filenames)
  filenames.each do |filename|
    get_entry(filename).time = modified_time
  end
end

#writable?(filename) ⇒ Boolean Also known as: writable_real?

Returns:

  • (Boolean) 


206
207
208
 
# File 'lib/zip/filesystem.rb', line 206

def writable?(filename)
  unix_mode_cmp(filename, 0o222)
end

#zero?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


288
289
290
291
292
293
 
# File 'lib/zip/filesystem.rb', line 288

def zero?(filename)
  sz = size(filename)
  sz.nil? || sz == 0
rescue Errno::ENOENT
  false
end