Class: Zip::ZipFileSystem::ZipFsFile

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

Overview

Instances of this class are normally accessed via the accessor ZipFile::file. An instance of ZipFsFile behaves like ruby’s builtin File (class) object, except it works on ZipFile 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.



156
157
158
 
# File 'lib/zip/zipfilesystem.rb', line 156

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/zipfilesystem.rb', line 69

def dir=(value)
  @dir = value
end

Instance Method Details

#atime(fileName) ⇒ Object 



312
313
314
315
316
317
318
319
 
# File 'lib/zip/zipfilesystem.rb', line 312

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

#basename(fileName) ⇒ Object 



290
291
292
 
# File 'lib/zip/zipfilesystem.rb', line 290

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

#blockdev?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


334
335
336
 
# File 'lib/zip/zipfilesystem.rb', line 334

def blockdev?(filename)
	false
end

#chardev?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


338
339
340
 
# File 'lib/zip/zipfilesystem.rb', line 338

def chardev?(filename)
	false
end

#chmod(modeInt, *filenames) ⇒ Object 



265
266
267
268
269
270
271
272
 
# File 'lib/zip/zipfilesystem.rb', line 265

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

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



253
254
255
256
257
258
259
260
261
262
263
 
# File 'lib/zip/zipfilesystem.rb', line 253

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 



321
322
323
324
325
326
327
328
 
# File 'lib/zip/zipfilesystem.rb', line 321

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 



395
396
397
398
399
400
401
402
403
 
# File 'lib/zip/zipfilesystem.rb', line 395

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) 


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

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

#dirname(fileName) ⇒ Object 



286
287
288
 
# File 'lib/zip/zipfilesystem.rb', line 286

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

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

Returns:

  • (Boolean) 


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

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

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

Returns:

  • (Boolean) 


178
179
180
 
# File 'lib/zip/zipfilesystem.rb', line 178

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

#expand_path(aPath) ⇒ Object 



411
412
413
 
# File 'lib/zip/zipfilesystem.rb', line 411

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

#file?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


281
282
283
284
 
# File 'lib/zip/zipfilesystem.rb', line 281

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

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



391
392
393
 
# File 'lib/zip/zipfilesystem.rb', line 391

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

#ftype(fileName) ⇒ Object 



350
351
352
 
# File 'lib/zip/zipfilesystem.rb', line 350

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

#join(*fragments) ⇒ Object 



298
299
300
 
# File 'lib/zip/zipfilesystem.rb', line 298

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

#link(fileName, symlinkName) ⇒ Object

Raises:

  • (NotImplementedError) 


362
363
364
 
# File 'lib/zip/zipfilesystem.rb', line 362

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

#mtime(fileName) ⇒ Object 



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

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

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



239
240
241
 
# File 'lib/zip/zipfilesystem.rb', line 239

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

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



227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/zip/zipfilesystem.rb', line 227

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

#pipe ⇒ Object

Raises:

  • (NotImplementedError) 


366
367
368
 
# File 'lib/zip/zipfilesystem.rb', line 366

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

#pipe?(filename) ⇒ Boolean

Returns:

  • (Boolean) 


330
331
332
 
# File 'lib/zip/zipfilesystem.rb', line 330

def pipe?(filename)
	false
end

#popen(*args, &aProc) ⇒ Object 



387
388
389
 
# File 'lib/zip/zipfilesystem.rb', line 387

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

#read(fileName) ⇒ Object 



383
384
385
 
# File 'lib/zip/zipfilesystem.rb', line 383

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

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

Returns:

  • (Boolean) 


187
188
189
 
# File 'lib/zip/zipfilesystem.rb', line 187

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

#readlines(fileName) ⇒ Object 



379
380
381
 
# File 'lib/zip/zipfilesystem.rb', line 379

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

#readlink(fileName) ⇒ Object

Raises:

  • (NotImplementedError) 


354
355
356
 
# File 'lib/zip/zipfilesystem.rb', line 354

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

#rename(fileToRename, newName) ⇒ Object 



405
406
407
 
# File 'lib/zip/zipfilesystem.rb', line 405

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

#setgid?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#setuid?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#size(fileName) ⇒ Object 



243
244
245
 
# File 'lib/zip/zipfilesystem.rb', line 243

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

#size?(fileName) ⇒ Boolean

Returns nil for not found and nil for directories

Returns:

  • (Boolean) 


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

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

#socket?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


346
347
348
 
# File 'lib/zip/zipfilesystem.rb', line 346

def socket?(fileName)
	false
end

#split(fileName) ⇒ Object 



294
295
296
 
# File 'lib/zip/zipfilesystem.rb', line 294

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

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



370
371
372
373
374
375
 
# File 'lib/zip/zipfilesystem.rb', line 370

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

#sticky?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


210
211
212
 
# File 'lib/zip/zipfilesystem.rb', line 210

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

#symlink(fileName, symlinkName) ⇒ Object

Raises:

  • (NotImplementedError) 


358
359
360
 
# File 'lib/zip/zipfilesystem.rb', line 358

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

#symlink?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


342
343
344
 
# File 'lib/zip/zipfilesystem.rb', line 342

def symlink?(fileName)
	false
end

#truncate(fileName, len) ⇒ Object

Raises:

  • (StandardError) 


218
219
220
 
# File 'lib/zip/zipfilesystem.rb', line 218

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

#umask(*args) ⇒ Object 



214
215
216
 
# File 'lib/zip/zipfilesystem.rb', line 214

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

#utime(modifiedTime, *fileNames) ⇒ Object 



302
303
304
305
306
 
# File 'lib/zip/zipfilesystem.rb', line 302

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

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

Returns:

  • (Boolean) 


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

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

#zero?(fileName) ⇒ Boolean

Returns:

  • (Boolean) 


274
275
276
277
278
279
 
# File 'lib/zip/zipfilesystem.rb', line 274

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