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

Returns a new instance of 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



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

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

#basename(filename) ⇒ Object



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

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

#blockdev?(_filename) ⇒ Boolean

Returns:

  • (Boolean)


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

def blockdev?(_filename)
  false
end

#chardev?(_filename) ⇒ Boolean

Returns:

  • (Boolean)


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

def chardev?(_filename)
  false
end

#chmod(mode, *filenames) ⇒ Object



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

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



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

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



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

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

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



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

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)


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



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

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

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

Returns:

  • (Boolean)


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?

Returns:

  • (Boolean)


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



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

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

#file?(filename) ⇒ Boolean

Returns:

  • (Boolean)


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

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



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

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

#ftype(filename) ⇒ Object



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

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

#join(*fragments) ⇒ Object



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

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

Raises:

  • (NotImplementedError)


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

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

#mtime(filename) ⇒ Object



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

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

#pipeObject

Raises:

  • (NotImplementedError)


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

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

#pipe?(_filename) ⇒ Boolean

Returns:

  • (Boolean)


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

def pipe?(_filename)
  false
end

#popen(*args, &a_proc) ⇒ Object



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

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

#read(filename) ⇒ Object



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

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

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

Returns:

  • (Boolean)


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

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

#readlines(filename) ⇒ Object



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

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

Raises:

  • (NotImplementedError)


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

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

#rename(file_to_rename, new_name) ⇒ Object



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

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

#setgid?(filename) ⇒ Boolean

Returns:

  • (Boolean)


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

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

#setuid?(filename) ⇒ Boolean

Returns:

  • (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

Returns:

  • (Boolean)


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

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

#socket?(_filename) ⇒ Boolean

Returns:

  • (Boolean)


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

def socket?(_filename)
  false
end

#split(filename) ⇒ Object



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

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

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

Raises:

  • (Errno::ENOENT)


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

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

  Stat.new(self, filename)
end

#sticky?(filename) ⇒ Boolean

Returns:

  • (Boolean)


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

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

Raises:

  • (NotImplementedError)


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

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

#symlink?(filename) ⇒ Boolean

Returns:

  • (Boolean)


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

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



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

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?

Returns:

  • (Boolean)


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

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

#zero?(filename) ⇒ Boolean

Returns:

  • (Boolean)


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

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