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(mappedZip) ⇒ ZipFsFile

Returns a new instance of ZipFsFile.



161
162
163
 
# File 'lib/zip/filesystem.rb', line 161

def initialize(mappedZip)
  @mappedZip = mappedZip
end

Instance Attribute Details

#dir=(value) ⇒ Object (writeonly)

Sets the attribute dir

Parameters:

  • value —

    the value to set the attribute dir to.



69
70
71
 
# File 'lib/zip/filesystem.rb', line 69

def dir=(value)
  @dir = value
end

Instance Method Details

#atime(fileName) ⇒ Object 



319
320
321
322
323
324
325
326
 
# File 'lib/zip/filesystem.rb', line 319

def atime(fileName)
  e = get_entry(fileName)
  if e.extra.member? "UniversalTime"
    e.extra["UniversalTime"].atime
  else
    nil
  end
end

#basename(fileName) ⇒ Object 



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

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

#blockdev?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


341
342
343
 
# File 'lib/zip/filesystem.rb', line 341

def blockdev?(filename)
  false
end

#chardev?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


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

def chardev?(filename)
  false
end

#chmod(modeInt, *filenames) ⇒ Object 



270
271
272
273
274
275
276
277
278
279
 
# File 'lib/zip/filesystem.rb', line 270

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

#chown(ownerInt, groupInt, *filenames) ⇒ Object 



258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/zip/filesystem.rb', line 258

def chown(ownerInt, groupInt, *filenames)
  filenames.each { |fileName|
    e = get_entry(fileName)
    unless e.extra.member?("IUnix")
      e.extra.create("IUnix")
    end
    e.extra["IUnix"].uid = ownerInt
    e.extra["IUnix"].gid = groupInt
  }
  filenames.size
end

#ctime(fileName) ⇒ Object 



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

def ctime(fileName)
  e = get_entry(fileName)
  if e.extra.member? "UniversalTime"
    e.extra["UniversalTime"].ctime
  else
    nil
  end
end

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



402
403
404
405
406
407
408
409
410
 
# File 'lib/zip/filesystem.rb', line 402

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

#directory?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def directory?(fileName)
  entry = @mappedZip.find_entry(fileName)
  expand_path(fileName) == "/" || (entry != nil && entry.directory?)
end

#dirname(fileName) ⇒ Object 



293
294
295
 
# File 'lib/zip/filesystem.rb', line 293

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

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

Returns:

  • (Boolean) 


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

def executable?(fileName)
  unix_mode_cmp(fileName, 0111)
end

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

Returns:

  • (Boolean) 


183
184
185
 
# File 'lib/zip/filesystem.rb', line 183

def exists?(fileName)
  expand_path(fileName) == "/" || @mappedZip.find_entry(fileName) != nil
end

#expand_path(aPath) ⇒ Object 



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

def expand_path(aPath)
  @mappedZip.expand_path(aPath)
end

#file?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def file?(fileName)
  entry = @mappedZip.find_entry(fileName)
  entry != nil && entry.file?
end

#foreach(fileName, aSep = $/, &aProc) ⇒ Object 



398
399
400
 
# File 'lib/zip/filesystem.rb', line 398

def foreach(fileName, aSep = $/, &aProc)
  open(fileName) { |is| is.each_line(aSep, &aProc) }
end

#ftype(fileName) ⇒ Object 



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

def ftype(fileName)
  @mappedZip.get_entry(fileName).directory? ? "directory" : "file"
end

#join(*fragments) ⇒ Object 



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

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

#link(fileName, symlinkName) ⇒ Object

Raises:

  • (NotImplementedError) 


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

def link(fileName, symlinkName)
  raise NotImplementedError, "The link() function is not implemented"
end

#mtime(fileName) ⇒ Object 



315
316
317
 
# File 'lib/zip/filesystem.rb', line 315

def mtime(fileName)
  @mappedZip.get_entry(fileName).mtime
end

#new(fileName, openMode = "r") ⇒ Object 



244
245
246
 
# File 'lib/zip/filesystem.rb', line 244

def new(fileName, openMode = "r")
  open(fileName, openMode)
end

#open(fileName, openMode = "r", permissionInt = 0644, &block) ⇒ Object 



232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/zip/filesystem.rb', line 232

def open(fileName, openMode = "r", permissionInt = 0644, &block)
  openMode.gsub!("b", "") # ignore b option
  case openMode
    when "r"
      @mappedZip.get_input_stream(fileName, &block)
    when "w"
      @mappedZip.get_output_stream(fileName, permissionInt, &block)
    else
      raise StandardError, "openmode '#{openMode} not supported" unless openMode == "r"
  end
end

#pipe ⇒ Object

Raises:

  • (NotImplementedError) 


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

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

#pipe?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


337
338
339
 
# File 'lib/zip/filesystem.rb', line 337

def pipe?(filename)
  false
end

#popen(*args, &aProc) ⇒ Object 



394
395
396
 
# File 'lib/zip/filesystem.rb', line 394

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

#read(fileName) ⇒ Object 



390
391
392
 
# File 'lib/zip/filesystem.rb', line 390

def read(fileName)
  @mappedZip.read(fileName)
end

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

Returns:

  • (Boolean) 


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

def readable?(fileName)
  unix_mode_cmp(fileName, 0444)
end

#readlines(fileName) ⇒ Object 



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

def readlines(fileName)
  open(fileName) { |is| is.readlines }
end

#readlink(fileName) ⇒ Object

Raises:

  • (NotImplementedError) 


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

def readlink(fileName)
  raise NotImplementedError, "The readlink() function is not implemented"
end

#rename(fileToRename, newName) ⇒ Object 



412
413
414
 
# File 'lib/zip/filesystem.rb', line 412

def rename(fileToRename, newName)
  @mappedZip.rename(fileToRename, newName) { true }
end

#setgid?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def setgid?(fileName)
  unix_mode_cmp(fileName, 02000)
end

#setuid?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def setuid?(fileName)
  unix_mode_cmp(fileName, 04000)
end

#size(fileName) ⇒ Object 



248
249
250
 
# File 'lib/zip/filesystem.rb', line 248

def size(fileName)
  @mappedZip.get_entry(fileName).size
end

#size?(fileName) ⇒ Boolean

Returns nil for not found and nil for directories

Returns:

  • (Boolean) 


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

def size?(fileName)
  entry = @mappedZip.find_entry(fileName)
  return (entry == nil || entry.directory?) ? nil : entry.size
end

#socket?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def socket?(fileName)
  false
end

#split(fileName) ⇒ Object 



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

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

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



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

def stat(fileName)
  if ! exists?(fileName)
    raise Errno::ENOENT, fileName
  end
  ZipFsStat.new(self, fileName)
end

#sticky?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def sticky?(fileName)
  unix_mode_cmp(fileName, 01000)
end

#symlink(fileName, symlinkName) ⇒ Object

Raises:

  • (NotImplementedError) 


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

def symlink(fileName, symlinkName)
  raise NotImplementedError, "The symlink() function is not implemented"
end

#symlink?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

def symlink?(fileName)
  false
end

#truncate(fileName, len) ⇒ Object

Raises:

  • (StandardError) 


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

def truncate(fileName, len)
  raise StandardError, "truncate not supported"
end

#umask(*args) ⇒ Object 



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

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

#utime(modifiedTime, *fileNames) ⇒ Object 



309
310
311
312
313
 
# File 'lib/zip/filesystem.rb', line 309

def utime(modifiedTime, *fileNames)
  fileNames.each { |fileName|
    get_entry(fileName).time = modifiedTime
  }
end

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

Returns:

  • (Boolean) 


197
198
199
 
# File 'lib/zip/filesystem.rb', line 197

def writable?(fileName)
  unix_mode_cmp(fileName, 0222)
end

#zero?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

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