Class: Zip::FileSystem::File

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

Overview

:nodoc:all

Defined Under Namespace

Classes: Stat

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(mapped_zip) ⇒ File 



16
17
18
 
# File 'lib/zip/filesystem/file.rb', line 16

def initialize(mapped_zip)
  @mapped_zip = mapped_zip
end

Instance Attribute Details

#dir=(value) ⇒ Object (writeonly)

:nodoc:all



14
15
16
 
# File 'lib/zip/filesystem/file.rb', line 14

def dir=(value)
  @dir = value
end

Instance Method Details

#atime(filename) ⇒ Object 



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

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

#basename(filename) ⇒ Object 



148
149
150
 
# File 'lib/zip/filesystem/file.rb', line 148

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

#blockdev?(_filename) ⇒ Boolean 



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

def blockdev?(_filename)
  false
end

#chardev?(_filename) ⇒ Boolean 



186
187
188
 
# File 'lib/zip/filesystem/file.rb', line 186

def chardev?(_filename)
  false
end

#chmod(mode, *filenames) ⇒ Object 



122
123
124
125
126
127
128
129
130
 
# File 'lib/zip/filesystem/file.rb', line 122

def chmod(mode, *filenames)
  filenames.each do |filename|
    e = find_entry(filename)
    e.fstype = FSTYPE_UNIX # Force conversion filesystem type to unix.
    e.unix_perms = mode
    e.external_file_attributes = mode << 16
  end
  filenames.size
end

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



112
113
114
115
116
117
118
119
120
 
# File 'lib/zip/filesystem/file.rb', line 112

def chown(owner, group, *filenames)
  filenames.each do |filename|
    e = find_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 



174
175
176
 
# File 'lib/zip/filesystem/file.rb', line 174

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

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



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

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 



80
81
82
83
 
# File 'lib/zip/filesystem/file.rb', line 80

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

#dirname(filename) ⇒ Object 



144
145
146
 
# File 'lib/zip/filesystem/file.rb', line 144

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

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



55
56
57
 
# File 'lib/zip/filesystem/file.rb', line 55

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

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



36
37
38
 
# File 'lib/zip/filesystem/file.rb', line 36

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

#expand_path(path) ⇒ Object 



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

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

#file?(filename) ⇒ Boolean 



139
140
141
142
 
# File 'lib/zip/filesystem/file.rb', line 139

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

#find_entry(filename) ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/zip/filesystem/file.rb', line 20

def find_entry(filename)
  unless exists?(filename)
    raise Errno::ENOENT, "No such file or directory - #{filename}"
  end

  @mapped_zip.find_entry(filename)
end

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



238
239
240
 
# File 'lib/zip/filesystem/file.rb', line 238

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

#ftype(filename) ⇒ Object 



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

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

#join(*fragments) ⇒ Object 



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

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

#link(_filename, _symlink_name) ⇒ Object

Raises:

  • (NotImplementedError) 


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

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

#mtime(filename) ⇒ Object 



166
167
168
 
# File 'lib/zip/filesystem/file.rb', line 166

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

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



97
98
99
 
# File 'lib/zip/filesystem/file.rb', line 97

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

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



85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/zip/filesystem/file.rb', line 85

def open(filename, mode = 'r', permissions = 0o644, &block)
  mode = mode.tr('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) 


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

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

#pipe?(_filename) ⇒ Boolean 



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

def pipe?(_filename)
  false
end

#popen(*args, &a_proc) ⇒ Object 



234
235
236
 
# File 'lib/zip/filesystem/file.rb', line 234

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

#read(filename) ⇒ Object 



230
231
232
 
# File 'lib/zip/filesystem/file.rb', line 230

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

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



45
46
47
 
# File 'lib/zip/filesystem/file.rb', line 45

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

#readlines(filename) ⇒ Object 



226
227
228
 
# File 'lib/zip/filesystem/file.rb', line 226

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

#readlink(_filename) ⇒ Object

Raises:

  • (NotImplementedError) 


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

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

#rename(file_to_rename, new_name) ⇒ Object 



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

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

#setgid?(filename) ⇒ Boolean 



64
65
66
 
# File 'lib/zip/filesystem/file.rb', line 64

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

#setuid?(filename) ⇒ Boolean 



60
61
62
 
# File 'lib/zip/filesystem/file.rb', line 60

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

#size(filename) ⇒ Object 



101
102
103
 
# File 'lib/zip/filesystem/file.rb', line 101

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

#size?(filename) ⇒ Boolean

Returns nil for not found and nil for directories. We disable the cop here for compatibility with ‘::File.size?`.



107
108
109
110
 
# File 'lib/zip/filesystem/file.rb', line 107

def size?(filename)
  entry = @mapped_zip.find_entry(filename)
  entry.nil? || entry.directory? ? nil : entry.size # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
end

#socket?(_filename) ⇒ Boolean 



194
195
196
 
# File 'lib/zip/filesystem/file.rb', line 194

def socket?(_filename)
  false
end

#split(filename) ⇒ Object 



152
153
154
 
# File 'lib/zip/filesystem/file.rb', line 152

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

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

Raises:

  • (Errno::ENOENT) 


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

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

  Stat.new(self, filename)
end

#sticky?(filename) ⇒ Boolean 



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

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

#symlink(_filename, _symlink_name) ⇒ Object

Raises:

  • (NotImplementedError) 


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

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

#symlink?(filename) ⇒ Boolean 



190
191
192
 
# File 'lib/zip/filesystem/file.rb', line 190

def symlink?(filename)
  @mapped_zip.get_entry(filename).symlink?
end

#truncate(_filename, _len) ⇒ Object

Raises:

  • (StandardError) 


76
77
78
 
# File 'lib/zip/filesystem/file.rb', line 76

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

#umask(*args) ⇒ Object 



72
73
74
 
# File 'lib/zip/filesystem/file.rb', line 72

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

#utime(modified_time, *filenames) ⇒ Object 



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

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

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



50
51
52
 
# File 'lib/zip/filesystem/file.rb', line 50

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

#zero?(filename) ⇒ Boolean 



132
133
134
135
136
137
 
# File 'lib/zip/filesystem/file.rb', line 132

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