Class: FakeFS::File
- Inherits:
-
StringIO
- Object
- StringIO
- FakeFS::File
- Defined in:
- lib/fakefs/file.rb,
lib/fakefs/flockable_file.rb
Overview
Be careful using this, as it may break things if you obtain more that one flock per file using different descriptors. Real flock call blocks/returns false in that case - see man7.org/linux/man-pages/man2/flock.2.html, it says it “may be denied”, but it does, it fact, deny. This implementation simply returns 0. This may also be a problem if you, it fact, are accessing a real file, which is locked by another process.
Defined Under Namespace
Classes: Stat
Constant Summary collapse
- MODES =
[ READ_ONLY = 'r'.freeze, READ_WRITE = 'r+'.freeze, WRITE_ONLY = 'w'.freeze, READ_WRITE_TRUNCATE = 'w+'.freeze, APPEND_WRITE_ONLY = 'a'.freeze, APPEND_READ_WRITE = 'a+'.freeze ].freeze
- FMODE_READABLE =
0x00000001
- FMODE_WRITABLE =
0x00000002
- FMODE_READWRITE =
(FMODE_READABLE | FMODE_WRITABLE)
- FMODE_BINMODE =
0x00000004
- FMODE_APPEND =
0x00000040
- FMODE_CREATE =
0x00000080
- FMODE_EXCL =
0x00000400
- FMODE_TRUNC =
0x00000800
- FMODE_TEXTMODE =
0x00001000
- TEXT_MODES =
{ 'r' => FMODE_READABLE, 'w' => FMODE_WRITABLE | FMODE_TRUNC | FMODE_CREATE, 'a' => FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE }.freeze
- FILE_CREATION_MODES =
(MODES - [READ_ONLY, READ_WRITE]).freeze
- FILE_ACCESS_MODE =
(RealFile::RDONLY | RealFile::WRONLY | RealFile::RDWR)
- MODE_BITMASK =
( RealFile::RDONLY | RealFile::WRONLY | RealFile::RDWR | RealFile::APPEND | RealFile::CREAT | RealFile::EXCL | RealFile::NONBLOCK | RealFile::TRUNC | RealFile::BINARY | (RealFile.const_defined?(:NOCTTY) ? RealFile::NOCTTY : 0) | (RealFile.const_defined?(:SYNC) ? RealFile::SYNC : 0) )
- FAKE_FS_ALLOWED_FLOCK_MODES =
yep, File::LOCK_UN | File::LOCK_NB is allowed
[RealFile::LOCK_EX, RealFile::LOCK_SH, RealFile::LOCK_UN].flat_map do |mode| [mode, mode | RealFile::LOCK_NB] end.freeze
Instance Attribute Summary collapse
-
#autoclose ⇒ Object
Returns the value of attribute autoclose.
-
#path ⇒ Object
readonly
Returns the value of attribute path.
Class Method Summary collapse
- .absolute_path(file_name, dir_name = Dir.getwd) ⇒ Object
- .atime(path) ⇒ Object
- .basename(*args) ⇒ Object
- .binread(file, length = nil, offset = 0) ⇒ Object
- .binwrite(file, content, offset = nil) ⇒ Object
- .birthtime(path) ⇒ Object
- .chmod(new_mode, filename) ⇒ Object
- .chown(owner_int, group_int, filename) ⇒ Object
- .const_missing(name) ⇒ Object
- .ctime(path) ⇒ Object
- .delete(*files) ⇒ Object (also: unlink)
- .directory?(path) ⇒ Boolean
- .dirname(*args) ⇒ Object
-
.executable?(filename) ⇒ Boolean
Not exactly right, returns true if the file is chmod +x for owner.
- .exist?(path) ⇒ Boolean
- .expand_path(file_name, dir_string = FileSystem.current_dir.to_s) ⇒ Object
- .extname(path) ⇒ Object
- .file?(path) ⇒ Boolean
- .fnmatch?(pattern, path, flags = 0) ⇒ Boolean (also: fnmatch)
- .foreach(path, *args, &block) ⇒ Object
- .ftype(filename) ⇒ Object
- .identical?(one_path, another_path) ⇒ Boolean
- .join(*parts) ⇒ Object
- .link(source, dest) ⇒ Object
- .lstat(file) ⇒ Object
- .mtime(path) ⇒ Object
- .path(file) ⇒ Object
-
.read(path, *args) ⇒ Object
TODO: support open_key_args.
- .readable?(path) ⇒ Boolean
- .readlines(path, chomp: false) ⇒ Object
- .readlink(path) ⇒ Object
- .realdirpath(*args) ⇒ Object
- .realpath(*args) ⇒ Object
- .rename(source, dest) ⇒ Object
- .size(path) ⇒ Object
- .size?(path) ⇒ Boolean
- .split(path) ⇒ Object
- .stat(file) ⇒ Object
-
.sticky?(_path) ⇒ Boolean
Assume nothing is sticky.
- .symlink(source, dest) ⇒ Object
- .symlink?(path) ⇒ Boolean
- .umask(*args) ⇒ Object
- .utime(atime, mtime, *paths) ⇒ Object
- .writable?(path) ⇒ Boolean
- .write(filename, contents, offset = nil, **open_args) ⇒ Object
- .zero?(path) ⇒ Boolean (also: empty?)
Instance Method Summary collapse
- #advise(_advice, _offset = 0, _len = 0) ⇒ Object
- #atime ⇒ Object
- #autoclose? ⇒ Boolean
- #binmode? ⇒ Boolean
- #birthtime ⇒ Object
- #chmod(new_mode) ⇒ Object
- #chown(owner_int, group_int) ⇒ Object
- #close_on_exec=(_bool) ⇒ Object
- #close_on_exec? ⇒ Boolean
- #ctime ⇒ Object
- #exists? ⇒ Boolean
- #flock(mode) ⇒ Object
-
#initialize(path, *args) ⇒ File
constructor
A new instance of File.
- #ioctl ⇒ Object
- #is_a?(klass) ⇒ Boolean
- #lstat ⇒ Object
- #mtime ⇒ Object
- #read_nonblock ⇒ Object
- #readpartial ⇒ Object
- #size ⇒ Object
- #stat ⇒ Object
- #string ⇒ Object
- #sysseek(position, whence = SEEK_SET) ⇒ Object
- #syswrite ⇒ Object
- #to_io ⇒ Object
- #to_path ⇒ Object
- #write(*args) ⇒ Object
- #write_nonblock ⇒ Object
Constructor Details
#initialize(path, *args) ⇒ File
Returns a new instance of File.
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 |
# File 'lib/fakefs/file.rb', line 511 def initialize(path, *args) # unable to pass args otherwise on jruby, it may cause false passes on MRI, though # because explicit hash isn't supported opts = args.last.is_a?(Hash) ? args.pop : {} if args.size > 2 raise ArgumentError, "wrong number of arguments (given #{args.size + 1}, expected 1..3)" end mode, _perm = args @path = path @file = FileSystem.find(@path) # real rb_scan_open_args - and rb_io_extract_modeenc - is much more complex raise ArgumentError, 'mode specified twice' unless mode.nil? || opts[:mode].nil? mode_opt = mode.nil? ? opts[:mode] : mode # see vmode_handle if mode_opt.nil? @oflags = RealFile::RDONLY elsif mode_opt.respond_to?(:to_int) && (intmode = mode_opt.to_int).instance_of?(Integer) @oflags = intmode else unless mode_opt.is_a?(String) unless mode_opt.respond_to?(:to_str) raise TypeError, "no implicit conversion of #{mode_opt.class} into String" end strmode = mode_opt.to_str unless strmode.is_a?(String) raise TypeError, "can't convert #{mode_opt.class} to String " \ "(#{mode_opt.class}#to_str gives #{strmode.class})" end mode_opt = strmode end @oflags, @fmode = parse_strmode_oflags(mode_opt) end unless opts[:flags].nil? if opts[:flags].is_a?(Integer) @oflags |= opts[:flags] elsif opts[:flags].respond_to?(:to_int) intflags = opts[:flags].to_int unless intflags.instance_of?(Integer) raise TypeError, "can't convert #{opts[:flags].class} to Integer " \ "(#{opts[:flags].class}#to_int gives #{intflags.class})" end @oflags |= intflags @fmode = create_fmode(@oflags) else raise TypeError, "no implicit conversion of #{opts[:flags].class} into Integer" end end @fmode ||= create_fmode(@oflags) @fmode = extract_binmode(opts, @fmode) @autoclose = true file_creation_mode? ? create_missing_file : check_file_existence! # StringIO changes enciding of the underlying string to binary # when binary data is written if it's opened in binary mode, # so content might have binary encoding. StringIO also switches to # binary mode if its string have binary encoding, but it might not # be what we want, so insteed we use encoding parsed after super call # and force set it back. # truncate doesn't work @file.content.force_encoding(Encoding.default_external) # StringIO.new 'content', nil, **{} # works in MRI, but fails in JRuby # but File.open 'filename', nil, **{} is ok both in MRI and JRuby # JRuby StringIO doesn't support kwargs without mode # StringIO.new "buff", encoding: 'binary' # work on MRI, fails on JRuby if RUBY_PLATFORM == "java" # other opts aren't supported super(@file.content, mode_opt || 'r') binmode if binmode? # Looks like it doesn't care about 'b' mode_opt_str = mode_opt.is_a?(String) ? mode_opt : '' raise ArgumentError, 'encoding specified twice' if mode_opt_str[':'] && opts[:encoding] # Might raise where real File just warns str_encoding = mode_opt_str.split(':')[1] # internal encoding is ignored anyway if opts[:encoding] set_encoding(opts[:encoding]) elsif str_encoding && str_encoding != '' set_encoding(str_encoding) elsif opts[:binmode] set_encoding(Encoding::BINARY) end else super(@file.content, mode, **opts) end # StringIO is wrtable and readable by default, so we need to disable it # but maybe it was explicitly disabled by opts close_write if @fmode & FMODE_WRITABLE == 0 && !StringIO.instance_method(:closed_write?).bind(self).call close_read if @fmode & FMODE_READABLE == 0 && !StringIO.instance_method(:closed_read?).bind(self).call end |
Instance Attribute Details
#autoclose ⇒ Object
Returns the value of attribute autoclose.
748 749 750 |
# File 'lib/fakefs/file.rb', line 748 def autoclose @autoclose end |
#path ⇒ Object (readonly)
Returns the value of attribute path.
509 510 511 |
# File 'lib/fakefs/file.rb', line 509 def path @path end |
Class Method Details
.absolute_path(file_name, dir_name = Dir.getwd) ⇒ Object
744 745 746 |
# File 'lib/fakefs/file.rb', line 744 def self.absolute_path(file_name, dir_name = Dir.getwd) RealFile.absolute_path(file_name, dir_name) end |
.atime(path) ⇒ Object
107 108 109 110 111 112 113 |
# File 'lib/fakefs/file.rb', line 107 def self.atime(path) if exist?(path) FileSystem.find(path).atime else raise Errno::ENOENT end end |
.basename(*args) ⇒ Object
188 189 190 |
# File 'lib/fakefs/file.rb', line 188 def self.basename(*args) RealFile.basename(*args) end |
.binread(file, length = nil, offset = 0) ⇒ Object
346 347 348 |
# File 'lib/fakefs/file.rb', line 346 def self.binread(file, length = nil, offset = 0) File.read(file, length, offset, mode: 'rb:ASCII-8BIT') end |
.binwrite(file, content, offset = nil) ⇒ Object
350 351 352 353 |
# File 'lib/fakefs/file.rb', line 350 def self.binwrite(file, content, offset = nil) mode = offset ? 'r+b:ASCII-8BIT' : 'wb:ASCII-8BIT' File.write(file, content, offset, mode: mode) end |
.birthtime(path) ⇒ Object
796 797 798 799 800 801 802 |
# File 'lib/fakefs/file.rb', line 796 def self.birthtime(path) if exist?(path) FileSystem.find(path).birthtime else raise Errno::ENOENT end end |
.chmod(new_mode, filename) ⇒ Object
309 310 311 312 313 314 315 316 317 318 319 |
# File 'lib/fakefs/file.rb', line 309 def self.chmod(new_mode, filename) # chmod's mode can either be passed in in absolute mode, or symbolic mode # for reference: https://ruby-doc.org/stdlib-2.2.2/libdoc/fileutils/rdoc/FileUtils.html#method-c-chmod # if the mode is passed in symbolic mode we must convert it to absolute mode is_absolute_mode = new_mode.is_a? Numeric unless is_absolute_mode current_mode = FileSystem.find(filename).mode new_mode = convert_symbolic_chmod_to_absolute(new_mode, current_mode) end FileSystem.find(filename).mode = 0o100000 + new_mode end |
.chown(owner_int, group_int, filename) ⇒ Object
329 330 331 332 333 334 335 336 337 338 339 340 |
# File 'lib/fakefs/file.rb', line 329 def self.chown(owner_int, group_int, filename) file = FileSystem.find(filename) if owner_int && owner_int != -1 owner_int.is_a?(Integer) || raise(TypeError, "can't convert String into Integer") file.uid = owner_int end if group_int && group_int != -1 group_int.is_a?(Integer) || raise(TypeError, "can't convert String into Integer") file.gid = group_int end end |
.const_missing(name) ⇒ Object
150 151 152 |
# File 'lib/fakefs/file.rb', line 150 def self.const_missing(name) RealFile.const_get(name) end |
.ctime(path) ⇒ Object
99 100 101 102 103 104 105 |
# File 'lib/fakefs/file.rb', line 99 def self.ctime(path) if exist?(path) FileSystem.find(path).ctime else raise Errno::ENOENT end end |
.delete(*files) ⇒ Object Also known as: unlink
278 279 280 281 282 283 284 285 286 287 |
# File 'lib/fakefs/file.rb', line 278 def self.delete(*files) files.each do |file| file_name = (file.class == FakeFS::File ? file.path : file.to_s) raise Errno::ENOENT, file_name unless exist?(file_name) FileUtils.rm(file_name) end files.size end |
.directory?(path) ⇒ Boolean
154 155 156 157 158 159 160 161 |
# File 'lib/fakefs/file.rb', line 154 def self.directory?(path) if path.respond_to? :entry path.entry.is_a? FakeDir else result = FileSystem.find(path) result ? result.entry.is_a?(FakeDir) : false end end |
.dirname(*args) ⇒ Object
192 193 194 |
# File 'lib/fakefs/file.rb', line 192 def self.dirname(*args) RealFile.dirname(*args) end |
.executable?(filename) ⇒ Boolean
Not exactly right, returns true if the file is chmod +x for owner. In the context of when you would use fakefs, this is usually what you want.
323 324 325 326 327 |
# File 'lib/fakefs/file.rb', line 323 def self.executable?(filename) file = FileSystem.find(filename) return false unless file (file.mode - 0o100000) & 0o100 != 0 end |
.exist?(path) ⇒ Boolean
61 62 63 64 65 66 67 68 |
# File 'lib/fakefs/file.rb', line 61 def self.exist?(path) if File.symlink?(path) referent = File.(File.readlink(path), File.dirname(path)) exist?(referent) else !FileSystem.find(path).nil? end end |
.expand_path(file_name, dir_string = FileSystem.current_dir.to_s) ⇒ Object
184 185 186 |
# File 'lib/fakefs/file.rb', line 184 def self.(file_name, dir_string = FileSystem.current_dir.to_s) RealFile.(file_name, RealFile.(dir_string, Dir.pwd)) end |
.extname(path) ⇒ Object
49 50 51 |
# File 'lib/fakefs/file.rb', line 49 def self.extname(path) RealFile.extname(path) end |
.file?(path) ⇒ Boolean
171 172 173 174 175 176 177 178 |
# File 'lib/fakefs/file.rb', line 171 def self.file?(path) if path.respond_to? :entry path.entry.is_a? FakeFile else result = FileSystem.find(path) result ? result.entry.is_a?(FakeFile) : false end end |
.fnmatch?(pattern, path, flags = 0) ⇒ Boolean Also known as: fnmatch
355 356 357 |
# File 'lib/fakefs/file.rb', line 355 def self.fnmatch?(pattern, path, flags = 0) RealFile.fnmatch?(pattern, path, flags) end |
.foreach(path, *args, &block) ⇒ Object
226 227 228 229 230 231 232 233 234 235 236 237 238 |
# File 'lib/fakefs/file.rb', line 226 def self.foreach(path, *args, &block) file = new(path) if file.exists? FileSystem.find(path).atime = Time.now if block_given? file.each_line(*args, &block) else file.each_line(*args) end else raise Errno::ENOENT end end |
.ftype(filename) ⇒ Object
180 181 182 |
# File 'lib/fakefs/file.rb', line 180 def self.ftype(filename) File.lstat(filename).ftype end |
.identical?(one_path, another_path) ⇒ Boolean
71 72 73 |
# File 'lib/fakefs/file.rb', line 71 def identical?(one_path, another_path) FileSystem.find(one_path) == FileSystem.find(another_path) end |
.join(*parts) ⇒ Object
53 54 55 |
# File 'lib/fakefs/file.rb', line 53 def self.join(*parts) RealFile.join(parts) end |
.link(source, dest) ⇒ Object
266 267 268 269 270 271 272 273 274 275 276 |
# File 'lib/fakefs/file.rb', line 266 def self.link(source, dest) raise Errno::EPERM, "#{source} or #{dest}" if directory?(source) raise Errno::ENOENT, "#{source} or #{dest}" unless exist?(source) raise Errno::EEXIST, "#{source} or #{dest}" if exist?(dest) source = FileSystem.find(source) dest = FileSystem.add(dest, source.entry.clone) source.link(dest) 0 end |
.lstat(file) ⇒ Object
301 302 303 |
# File 'lib/fakefs/file.rb', line 301 def self.lstat(file) File::Stat.new(file, true) end |
.mtime(path) ⇒ Object
91 92 93 94 95 96 97 |
# File 'lib/fakefs/file.rb', line 91 def self.mtime(path) if exist?(path) FileSystem.find(path).mtime else raise Errno::ENOENT end end |
.path(file) ⇒ Object
57 58 59 |
# File 'lib/fakefs/file.rb', line 57 def self.path(file) RealFile.path(file) end |
.read(path, *args) ⇒ Object
TODO: support open_key_args
202 203 204 205 206 207 208 209 210 211 212 213 214 |
# File 'lib/fakefs/file.rb', line 202 def self.read(path, *args) = args[-1].is_a?(Hash) ? args.pop : {} length = args.empty? ? nil : args.shift offset = args.empty? ? 0 : args.shift file = new(path, **) raise Errno::ENOENT unless file.exists? raise Errno::EISDIR, path.to_s if directory?(path) FileSystem.find(path).atime = Time.now file.seek(offset) file.read(length) end |
.readable?(path) ⇒ Boolean
81 82 83 84 |
# File 'lib/fakefs/file.rb', line 81 def self.readable?(path) return false unless exist? path File.lstat(path).readable? end |
.readlines(path, chomp: false) ⇒ Object
216 217 218 219 220 221 222 223 224 |
# File 'lib/fakefs/file.rb', line 216 def self.readlines(path, chomp: false) file = new(path) if file.exists? FileSystem.find(path).atime = Time.now chomp ? file.readlines.map(&:chomp) : file.readlines else raise Errno::ENOENT end end |
.readlink(path) ⇒ Object
196 197 198 199 |
# File 'lib/fakefs/file.rb', line 196 def self.readlink(path) symlink = FileSystem.find(path) symlink.target end |
.realdirpath(*args) ⇒ Object
760 761 762 |
# File 'lib/fakefs/file.rb', line 760 def self.realdirpath(*args) RealFile.realdirpath(*args) end |
.realpath(*args) ⇒ Object
723 724 725 |
# File 'lib/fakefs/file.rb', line 723 def self.realpath(*args) RealFile.realpath(*args) end |
.rename(source, dest) ⇒ Object
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
# File 'lib/fakefs/file.rb', line 240 def self.rename(source, dest) if directory?(source) && file?(dest) raise Errno::ENOTDIR, "#{source} or #{dest}" elsif file?(source) && directory?(dest) raise Errno::EISDIR, "#{source} or #{dest}" elsif !exist?(dirname(dest)) raise Errno::ENOENT, "#{source} or #{dest}" end if (target = FileSystem.find(source)) return 0 if source == dest if target.is_a?(FakeFS::FakeSymlink) File.symlink(target.target, dest) else FileSystem.add(dest, target.entry.clone) end FileSystem.delete(source) else raise Errno::ENOENT, "#{source} or #{dest}" end 0 end |
.size(path) ⇒ Object
128 129 130 131 132 133 134 |
# File 'lib/fakefs/file.rb', line 128 def self.size(path) if directory?(path) 64 + (32 * FileSystem.find(path).entries.size) else read(path).bytesize end end |
.size?(path) ⇒ Boolean
136 137 138 |
# File 'lib/fakefs/file.rb', line 136 def self.size?(path) size(path) if exist?(path) && !size(path).zero? end |
.split(path) ⇒ Object
305 306 307 |
# File 'lib/fakefs/file.rb', line 305 def self.split(path) RealFile.split(path) end |
.stat(file) ⇒ Object
297 298 299 |
# File 'lib/fakefs/file.rb', line 297 def self.stat(file) File::Stat.new(file) end |
.sticky?(_path) ⇒ Boolean
Assume nothing is sticky.
76 77 78 |
# File 'lib/fakefs/file.rb', line 76 def sticky?(_path) false end |
.symlink(source, dest) ⇒ Object
293 294 295 |
# File 'lib/fakefs/file.rb', line 293 def self.symlink(source, dest) FileUtils.ln_s(source, dest) end |
.symlink?(path) ⇒ Boolean
163 164 165 166 167 168 169 |
# File 'lib/fakefs/file.rb', line 163 def self.symlink?(path) if path.respond_to? :entry path.is_a? FakeSymlink else FileSystem.find(path).is_a? FakeSymlink end end |
.umask(*args) ⇒ Object
342 343 344 |
# File 'lib/fakefs/file.rb', line 342 def self.umask(*args) RealFile.umask(*args) end |
.utime(atime, mtime, *paths) ⇒ Object
115 116 117 118 119 120 121 122 123 124 125 126 |
# File 'lib/fakefs/file.rb', line 115 def self.utime(atime, mtime, *paths) paths.each do |path| if exist?(path) FileSystem.find(path).atime = atime FileSystem.find(path).mtime = mtime else raise Errno::ENOENT end end paths.size end |
.writable?(path) ⇒ Boolean
86 87 88 89 |
# File 'lib/fakefs/file.rb', line 86 def self.writable?(path) return false unless exist? path File.lstat(path).writable? end |
.write(filename, contents, offset = nil, **open_args) ⇒ Object
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 |
# File 'lib/fakefs/file.rb', line 766 def self.write(filename, contents, offset = nil, **open_args) mode = offset ? 'r+' : 'w' if open_args[:open_args] # see open_key_args # todo: foreach, readlines, read also use it # Treat a final argument as keywords if it is a hash, and not as keywords otherwise. open_args = open_args[:open_args] if open_args.last.is_a?(Hash) args = open_args[0...-1] opt = open_args.last else args = open_args opt = {} end else args = [open_args.delete(:mode) || mode] opt = open_args end if offset open(filename, *args, **opt) do |f| # rubocop:disable Security/Open f.seek(offset) f.write(contents) end else open(filename, *args, **opt) do |f| # rubocop:disable Security/Open f.write(contents) end end end |
.zero?(path) ⇒ Boolean Also known as: empty?
140 141 142 |
# File 'lib/fakefs/file.rb', line 140 def self.zero?(path) exist?(path) && size(path) == 0 end |
Instance Method Details
#advise(_advice, _offset = 0, _len = 0) ⇒ Object
764 |
# File 'lib/fakefs/file.rb', line 764 def advise(_advice, _offset = 0, _len = 0); end |
#atime ⇒ Object
681 682 683 |
# File 'lib/fakefs/file.rb', line 681 def atime self.class.atime(@path) end |
#autoclose? ⇒ Boolean
750 751 752 |
# File 'lib/fakefs/file.rb', line 750 def autoclose? @autoclose ? true : false end |
#binmode? ⇒ Boolean
727 728 729 730 |
# File 'lib/fakefs/file.rb', line 727 def binmode? # File.open('test_mode', mode: 'w:binary').binmode? # => false @fmode & FMODE_BINMODE != 0 end |
#birthtime ⇒ Object
804 805 806 |
# File 'lib/fakefs/file.rb', line 804 def birthtime self.class.birthtime(@path) end |
#chmod(new_mode) ⇒ Object
697 698 699 700 701 702 703 704 705 706 707 |
# File 'lib/fakefs/file.rb', line 697 def chmod(new_mode) # chmod's mode can either be passed in in absolute mode, or symbolic mode # for reference: https://ruby-doc.org/stdlib-2.2.2/libdoc/fileutils/rdoc/FileUtils.html#method-c-chmod # if the mode is passed in symbolic mode we must convert it to absolute mode is_absolute_mode = new_mode.is_a? Numeric unless is_absolute_mode current_mode = @file.mode new_mode = convert_symbolic_chmod_to_absolute(new_mode, current_mode) end @file.mode = 0o100000 + new_mode end |
#chown(owner_int, group_int) ⇒ Object
709 710 711 712 713 714 715 716 717 718 719 720 721 |
# File 'lib/fakefs/file.rb', line 709 def chown(owner_int, group_int) return unless group_int && group_int != -1 owner_int.is_a?(Integer) || raise( TypeError, "can't convert String into Integer" ) @file.uid = owner_int group_int.is_a?(Integer) || raise( TypeError, "can't convert String into Integer" ) @file.gid = group_int end |
#close_on_exec=(_bool) ⇒ Object
732 733 734 |
# File 'lib/fakefs/file.rb', line 732 def close_on_exec=(_bool) raise NotImplementedError end |
#close_on_exec? ⇒ Boolean
736 737 738 |
# File 'lib/fakefs/file.rb', line 736 def close_on_exec? raise NotImplementedError end |
#ctime ⇒ Object
685 686 687 |
# File 'lib/fakefs/file.rb', line 685 def ctime self.class.ctime(@path) end |
#exists? ⇒ Boolean
609 610 611 |
# File 'lib/fakefs/file.rb', line 609 def exists? true end |
#flock(mode) ⇒ Object
689 690 691 |
# File 'lib/fakefs/file.rb', line 689 def flock(*) raise NotImplementedError end |
#ioctl ⇒ Object
646 647 648 |
# File 'lib/fakefs/file.rb', line 646 def ioctl(*) raise NotImplementedError end |
#is_a?(klass) ⇒ Boolean
638 639 640 |
# File 'lib/fakefs/file.rb', line 638 def is_a?(klass) RealFile.allocate.is_a?(klass) end |
#lstat ⇒ Object
658 659 660 |
# File 'lib/fakefs/file.rb', line 658 def lstat self.class.lstat(@path) end |
#mtime ⇒ Object
693 694 695 |
# File 'lib/fakefs/file.rb', line 693 def mtime self.class.mtime(@path) end |
#read_nonblock ⇒ Object
650 651 652 |
# File 'lib/fakefs/file.rb', line 650 def read_nonblock raise NotImplementedError end |
#readpartial ⇒ Object
677 678 679 |
# File 'lib/fakefs/file.rb', line 677 def readpartial(*) super end |
#stat ⇒ Object
654 655 656 |
# File 'lib/fakefs/file.rb', line 654 def stat self.class.stat(@path) end |
#string ⇒ Object
642 643 644 |
# File 'lib/fakefs/file.rb', line 642 def string gets(nil) end |
#sysseek(position, whence = SEEK_SET) ⇒ Object
662 663 664 665 |
# File 'lib/fakefs/file.rb', line 662 def sysseek(position, whence = SEEK_SET) seek(position, whence) pos end |
#syswrite ⇒ Object
621 622 623 624 625 |
# File 'lib/fakefs/file.rb', line 621 def write(*args) val = super(*args) @file.mtime = Time.now val end |
#to_io ⇒ Object
669 670 671 |
# File 'lib/fakefs/file.rb', line 669 def to_io self end |
#to_path ⇒ Object
740 741 742 |
# File 'lib/fakefs/file.rb', line 740 def to_path @path end |
#write(*args) ⇒ Object
613 614 615 616 617 |
# File 'lib/fakefs/file.rb', line 613 def write(*args) val = super(*args) @file.mtime = Time.now val end |
#write_nonblock ⇒ Object
673 674 675 |
# File 'lib/fakefs/file.rb', line 673 def write_nonblock(*) raise NotImplementedError end |