class FakeFS::Pathname

pathname.rb - From MRI 1.9.2

Object-Oriented Pathname Class

Author

Tanaka Akira <akr@m17n.org>

Documentation

Author and Gavin Sinclair

For documentation, see class Pathname.

Pathname class

Pathname class

Pathname class

Pathname class

Pathname class

Pathname class

Pathname class

Pathname class

Constants

SAME_PATHS
SEPARATOR_LIST
SEPARATOR_PAT
TO_PATH

to_path is implemented so Pathname objects are usable with File.open, etc.

Public Class Methods

getwd() click to toggle source

See Dir.getwd. Returns the current working directory as a Pathname.

# File lib/fakefs/pathname.rb, line 922
def self.getwd
  new(Dir.getwd)
end
Also aliased as: pwd
glob(*args, **opts) { |pathname| ... } click to toggle source

See Dir.glob. Returns or yields Pathname objects.

# File lib/fakefs/pathname.rb, line 912
def self.glob(*args, **opts) # :yield: pathname
  if block_given?
    Dir.glob(*args, **opts) { |f| yield new(f) }
  else
    Dir.glob(*args, **opts).map { |f| new(f) }
  end
end
new(path) click to toggle source

Create a Pathname object from the given String (or String-like object). If path contains a NUL character (\0), an ArgumentError is raised.

# File lib/fakefs/pathname.rb, line 32
def initialize(path)
  path = path.__send__(TO_PATH) if path.respond_to? TO_PATH
  @path = path.dup

  if /\0/ =~ @path
    raise ArgumentError, "pathname contains \\0: #{@path.inspect}"
  end
end
pwd()
Alias for: getwd

Public Instance Methods

+(other) click to toggle source

Pathname#+ appends a pathname fragment to this one to produce a new Pathname object.

p1 = Pathname.new("/usr")      # Pathname:/usr
p2 = p1 + "bin/ruby"           # Pathname:/usr/bin/ruby
p3 = p1 + "/etc/passwd"        # Pathname:/etc/passwd

This method doesn’t access the file system; it is pure string manipulation.

# File lib/fakefs/pathname.rb, line 293
def +(other)
  other = Pathname.new(other) unless other.is_a?(Pathname)
  Pathname.new(plus(@path, other.to_s))
end
Also aliased as: /
/(other)
Alias for: +
<=>(other) click to toggle source

Provides for comparing pathnames, case-sensitively.

# File lib/fakefs/pathname.rb, line 61
def <=>(other)
  return nil unless other.is_a?(Pathname)
  @path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
end
==(other) click to toggle source

Compare this pathname with other. The comparison is string-based. Be aware that two different paths (foo.txt and ./foo.txt) can refer to the same file.

# File lib/fakefs/pathname.rb, line 52
def ==(other)
  return false unless other.is_a?(Pathname)
  other.to_s == @path
end
Also aliased as: ===, eql?
===(other)
Alias for: ==
TO_PATH()

to_path is implemented so Pathname objects are usable with File.open, etc.

Alias for: to_s
absolute?() click to toggle source

Predicate method for testing whether a path is absolute. It returns true if the pathname begins with a slash.

# File lib/fakefs/pathname.rb, line 198
def absolute?
  !relative?
end
ascend() { |self| ... } click to toggle source

Iterates over and yields a new Pathname object for each element in the given path in ascending order.

Pathname.new('/path/to/some/file.rb').ascend { |v| p v}
   #<Pathname:/path/to/some/file.rb>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to>
   #<Pathname:/path>
   #<Pathname:/>

Pathname.new('path/to/some/file.rb').ascend { |v| p v}
   #<Pathname:path/to/some/file.rb>
   #<Pathname:path/to/some>
   #<Pathname:path/to>
   #<Pathname:path>

It doesn’t access actual filesystem.

This method is available since 1.8.5.

# File lib/fakefs/pathname.rb, line 271
def ascend
  path = @path
  yield self
  while (r = chop_basename(path))
    path, _name = r
    break if path.empty?
    yield self.class.new(del_trailing_separator(path))
  end
end
atime() click to toggle source

See File.atime. Returns last access time.

# File lib/fakefs/pathname.rb, line 651
def atime
  File.atime(@path)
end
basename(*args) click to toggle source

See File.basename. Returns the last component of the path.

# File lib/fakefs/pathname.rb, line 749
def basename(*args)
  self.class.new(File.basename(@path, *args))
end
binread(*args) click to toggle source

See IO.binread. Returns all the bytes from the file, or the first N if specified.

# File lib/fakefs/pathname.rb, line 633
def binread(*args)
  File.binread(@path, *args)
end
blockdev?() click to toggle source

See FileTest.blockdev?.

# File lib/fakefs/pathname.rb, line 789
def blockdev?
  FileTest.blockdev?(@path)
end
chardev?() click to toggle source

See FileTest.chardev?.

# File lib/fakefs/pathname.rb, line 794
def chardev?
  FileTest.chardev?(@path)
end
children(with_directory = true) click to toggle source

Returns the children of the directory (files and subdirectories, not recursive) as an array of Pathname objects. By default, the returned pathnames will have enough information to access the files. If you set with_directory to false, then the returned pathnames will contain the filename only.

For example:

pn = Pathname("/usr/lib/ruby/1.8")
pn.children
  # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
         Pathname:/usr/lib/ruby/1.8/Env.rb,
         Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
pn.children(false)
  # -> [ Pathname:English.rb,
         Pathname:Env.rb,
         Pathname:abbrev.rb, ... ]

Note that the result never contain the entries . and .. in the directory because they are not children.

This method has existed since 1.8.1.

# File lib/fakefs/pathname.rb, line 343
def children(with_directory = true)
  with_directory = false if @path == '.'
  result = []
  Dir.foreach(@path) do |e|
    next if ['.', '..'].include?(e)
    result <<
      if with_directory
        self.class.new(File.join(@path, e))
      else
        self.class.new(e)
      end
  end
  result
end
chmod(mode) click to toggle source

See File.chmod. Changes permissions.

# File lib/fakefs/pathname.rb, line 667
def chmod(mode)
  File.chmod(mode, @path)
end
chown(owner, group) click to toggle source

See File.chown. Change owner and group of file.

# File lib/fakefs/pathname.rb, line 677
def chown(owner, group)
  File.chown(owner, group, @path)
end
cleanpath(consider_symlink = false) click to toggle source

Returns clean pathname of self with consecutive slashes and useless dots removed. The filesystem is not accessed.

If consider_symlink is true, then a more conservative algorithm is used to avoid breaking symbolic linkages. This may retain more .. entries than absolutely necessary, but without accessing the filesystem, this can’t be avoided. See realpath.

# File lib/fakefs/pathname.rb, line 136
def cleanpath(consider_symlink = false)
  if consider_symlink
    cleanpath_conservative
  else
    cleanpath_aggressive
  end
end
ctime() click to toggle source

See File.ctime. Returns last (directory entry, not file) change time.

# File lib/fakefs/pathname.rb, line 657
def ctime
  File.ctime(@path)
end
delete()
Alias for: unlink
descend() { |v| ... } click to toggle source

Iterates over and yields a new Pathname object for each element in the given path in descending order.

Pathname.new('/path/to/some/file.rb').descend { |v| p v}
   #<Pathname:/>
   #<Pathname:/path>
   #<Pathname:/path/to>
   #<Pathname:/path/to/some>
   #<Pathname:/path/to/some/file.rb>

Pathname.new('path/to/some/file.rb').descend { |v| p v}
   #<Pathname:path>
   #<Pathname:path/to>
   #<Pathname:path/to/some>
   #<Pathname:path/to/some/file.rb>

It doesn’t access actual filesystem.

This method is available since 1.8.5.

# File lib/fakefs/pathname.rb, line 244
def descend
  vs = []
  ascend { |v| vs << v }
  vs.reverse_each { |v| yield v }
  nil
end
directory?() click to toggle source

See FileTest.directory?.

# File lib/fakefs/pathname.rb, line 819
def directory?
  FileTest.directory?(@path)
end
dirname() click to toggle source

See File.dirname. Returns all but the last component of the path.

# File lib/fakefs/pathname.rb, line 755
def dirname
  self.class.new(File.dirname(@path))
end
each_child(with_directory = true, &block) click to toggle source

Iterates over the children of the directory (files and subdirectories, not recursive). It yields Pathname object for each child. By default, the yielded pathnames will have enough information to access the files. If you set with_directory to false, then the returned pathnames will contain the filename only.

Pathname("/usr/local").each_child { |f| p f }
#=> #<Pathname:/usr/local/share>
#   #<Pathname:/usr/local/bin>
#   #<Pathname:/usr/local/games>
#   #<Pathname:/usr/local/lib>
#   #<Pathname:/usr/local/include>
#   #<Pathname:/usr/local/sbin>
#   #<Pathname:/usr/local/src>
#   #<Pathname:/usr/local/man>

Pathname("/usr/local").each_child(false) { |f| p f }
#=> #<Pathname:share>
#   #<Pathname:bin>
#   #<Pathname:games>
#   #<Pathname:lib>
#   #<Pathname:include>
#   #<Pathname:sbin>
#   #<Pathname:src>
#   #<Pathname:man>
# File lib/fakefs/pathname.rb, line 386
def each_child(with_directory = true, &block)
  children(with_directory).each(&block)
end
each_entry(*) { |pathname| ... } click to toggle source

Iterates over the entries (files and subdirectories) in the directory. It yields a Pathname object for each entry.

This method has existed since 1.8.1.

# File lib/fakefs/pathname.rb, line 938
def each_entry(*) # :yield: pathname
  Dir.foreach(@path) { |f| yield self.class.new(f) }
end
each_filename() { |filename| ... } click to toggle source

Iterates over each component of the path.

Pathname.new("/usr/bin/ruby").each_filename { |filename| ... }
  # yields "usr", "bin", and "ruby".
# File lib/fakefs/pathname.rb, line 217
def each_filename # :yield: filename
  return to_enum(__method__) unless block_given?
  _prefix, names = split_names(@path)
  names.each { |filename| yield filename }
  nil
end
each_line(*args) { |line| ... } click to toggle source

each_line iterates over the line in the file. It yields a String object for each line.

This method has existed since 1.8.1.

# File lib/fakefs/pathname.rb, line 615
def each_line(*args, &block) # :yield: line
  if block_given?
    File.open(@path, 'r') do |io|
      io.each_line(*args, &block)
    end
  else
    enum_for(:each_line, *args)
  end
end
empty?() click to toggle source

Checks if a file or directory is empty, using FileTest.empty? or Dir.empty? as necessary.

# File lib/fakefs/pathname.rb, line 1026
def empty?
  if File.directory? @path
    Dir.empty? @path
  else
    FileTest.empty? @path
  end
end
entries() click to toggle source

Return the entries (files and subdirectories) in the directory, each as a Pathname object.

# File lib/fakefs/pathname.rb, line 930
def entries
  Dir.entries(@path).map { |f| self.class.new(f) }
end
eql?(other)
Alias for: ==
executable?() click to toggle source

See FileTest.executable?.

# File lib/fakefs/pathname.rb, line 799
def executable?
  FileTest.executable?(@path)
end
executable_real?() click to toggle source

See FileTest.executable_real?.

# File lib/fakefs/pathname.rb, line 804
def executable_real?
  FileTest.executable_real?(@path)
end
exist?() click to toggle source

See FileTest.exist?.

# File lib/fakefs/pathname.rb, line 809
def exist?
  FileTest.exist?(@path)
end
expand_path(*args) click to toggle source

See File.expand_path.

# File lib/fakefs/pathname.rb, line 765
def expand_path(*args)
  self.class.new(File.expand_path(@path, *args))
end
extname() click to toggle source

See File.extname. Returns the file’s extension.

# File lib/fakefs/pathname.rb, line 760
def extname
  File.extname(@path)
end
file?() click to toggle source

See FileTest.file?.

# File lib/fakefs/pathname.rb, line 824
def file?
  FileTest.file?(@path)
end
find(*) { |pathname| ... } click to toggle source

Pathname#find is an iterator to traverse a directory tree in a depth first manner. It yields a Pathname for each file under “this” directory.

Since it is implemented by find.rb, Find.prune can be used to control the traverse.

If self is ., yielded pathnames begin with a filename in the current directory, not ./.

# File lib/fakefs/pathname.rb, line 979
def find(*) # :yield: pathname
  require 'find'
  if @path == '.'
    Find.find(@path) { |f| yield self.class.new(f.sub(%r{/\A\./}, '')) }
  else
    Find.find(@path) { |f| yield self.class.new(f) }
  end
end
fnmatch(pattern, *args) click to toggle source

See File.fnmatch. Return true if the receiver matches the given pattern

# File lib/fakefs/pathname.rb, line 688
def fnmatch(pattern, *args)
  File.fnmatch(pattern, @path, *args)
end
fnmatch?(pattern, *args) click to toggle source

See File.fnmatch? (same as fnmatch).

# File lib/fakefs/pathname.rb, line 693
def fnmatch?(pattern, *args)
  File.fnmatch?(pattern, @path, *args)
end
freeze() click to toggle source
Calls superclass method
# File lib/fakefs/pathname.rb, line 41
def freeze
  super
  @path.freeze
  self
end
ftype() click to toggle source

See File.ftype. Returns “type” of file (“file”, “directory”, etc).

# File lib/fakefs/pathname.rb, line 699
def ftype
  File.ftype(@path)
end
glob(pattern, flags = 0) { |join(f)| ... } click to toggle source
# File lib/fakefs/pathname.rb, line 957
def glob(pattern, flags = 0)
  if block_given?
    Dir.glob(pattern, flags: flags, base: self) { |f| yield join(f) }
  else
    Dir.glob(pattern, flags: flags, base: self).map { |f| join(f) }
  end
end
grpowned?() click to toggle source

See FileTest.grpowned?.

# File lib/fakefs/pathname.rb, line 814
def grpowned?
  FileTest.grpowned?(@path)
end
join(*args) click to toggle source

Pathname#join joins pathnames.

path0.join(path1, ..., pathN) is the same as path0 + path1 + ... + pathN.

# File lib/fakefs/pathname.rb, line 305
def join(*args)
  args.unshift self
  result = args.pop
  result = Pathname.new(result) unless result.is_a?(Pathname)
  return result if result.absolute?
  args.reverse_each do |arg|
    arg = Pathname.new(arg) unless arg.is_a?(Pathname)
    result = arg + result
    return result if result.absolute?
  end
  result
end
lchmod(mode) click to toggle source

See File.lchmod.

# File lib/fakefs/pathname.rb, line 672
def lchmod(mode)
  File.lchmod(mode, @path)
end
lchown(owner, group) click to toggle source

See File.lchown.

# File lib/fakefs/pathname.rb, line 682
def lchown(owner, group)
  File.lchown(owner, group, @path)
end
lstat() click to toggle source

See File.lstat.

# File lib/fakefs/pathname.rb, line 729
def lstat
  File.lstat(@path)
end
mkdir(*args) click to toggle source

See Dir.mkdir. Create the referenced directory.

# File lib/fakefs/pathname.rb, line 943
def mkdir(*args)
  Dir.mkdir(@path, *args)
end
mkpath() click to toggle source

See FileUtils.mkpath. Creates a full path, including any intermediate directories that don’t yet exist.

# File lib/fakefs/pathname.rb, line 993
def mkpath
  require 'fileutils'
  FileUtils.mkpath(@path)
  nil
end
mountpoint?() click to toggle source

mountpoint? returns true if self points to a mountpoint.

# File lib/fakefs/pathname.rb, line 173
def mountpoint?
  stat1 = lstat
  begin
    stat2 = parent.lstat
    stat1.dev == stat2.dev && stat1.ino == stat2.ino ||
      stat1.dev != stat2.dev
  rescue Errno::ENOENT
    false
  end
end
mtime() click to toggle source

See File.mtime. Returns last modification time.

# File lib/fakefs/pathname.rb, line 662
def mtime
  File.mtime(@path)
end
open(*args) { |file| ... } click to toggle source

See File.open. Opens the file for reading or writing.

# File lib/fakefs/pathname.rb, line 709
def open(*args, &block) # :yield: file
  File.open(@path, *args, &block)
end
opendir() { |dir| ... } click to toggle source

See Dir.open.

# File lib/fakefs/pathname.rb, line 953
def opendir(&block) # :yield: dir
  Dir.open(@path, &block)
end
owned?() click to toggle source

See FileTest.owned?.

# File lib/fakefs/pathname.rb, line 839
def owned?
  FileTest.owned?(@path)
end
parent() click to toggle source

parent returns the parent directory.

This is same as self + '..'.

# File lib/fakefs/pathname.rb, line 168
def parent
  self + '..'
end
pipe?() click to toggle source

See FileTest.pipe?.

# File lib/fakefs/pathname.rb, line 829
def pipe?
  FileTest.pipe?(@path)
end
read(*args) click to toggle source

See IO.read. Returns all data from the file, or the first N bytes if specified.

# File lib/fakefs/pathname.rb, line 627
def read(*args)
  File.read(@path, *args)
end
readable?() click to toggle source

See FileTest.readable?.

# File lib/fakefs/pathname.rb, line 844
def readable?
  FileTest.readable?(@path)
end
readable_real?() click to toggle source

See FileTest.readable_real?.

# File lib/fakefs/pathname.rb, line 854
def readable_real?
  FileTest.readable_real?(@path)
end
readlines(*args) click to toggle source

See IO.readlines. Returns all the lines from the file.

# File lib/fakefs/pathname.rb, line 638
def readlines(*args)
  File.readlines(@path, *args)
end
realdirpath(basedir = nil) click to toggle source

Returns the real (absolute) pathname of self in the actual filesystem. The real pathname doesn’t contain symlinks or useless dots.

The last component of the real pathname can be nonexistent.

# File lib/fakefs/pathname.rb, line 161
def realdirpath(basedir = nil)
  self.class.new(File.realdirpath(@path, basedir))
end
realpath(basedir = nil) click to toggle source

Returns the real (absolute) pathname of self in the actual filesystem not containing symlinks or useless dots.

All components of the pathname must exist when this method is called.

# File lib/fakefs/pathname.rb, line 151
def realpath(basedir = nil)
  self.class.new(File.realpath(@path, basedir))
end
relative?() click to toggle source

The opposite of absolute?

# File lib/fakefs/pathname.rb, line 203
def relative?
  path = @path
  while (r = chop_basename(path))
    path, _basename = r
  end
  path == ''
end
relative_path_from(base_directory) click to toggle source

relative_path_from returns a relative path from the argument to the receiver. If self is absolute, the argument must be absolute too. If self is relative, the argument must be relative too.

relative_path_from doesn’t access the filesystem. It assumes no symlinks.

ArgumentError is raised when it cannot find a relative path.

This method has existed since 1.8.1.

# File lib/fakefs/pathname.rb, line 402
def relative_path_from(base_directory)
  dest_directory = cleanpath.to_s
  base_directory = base_directory.cleanpath.to_s
  dest_prefix = dest_directory
  dest_names = []
  while (r = chop_basename(dest_prefix))
    dest_prefix, basename = r
    dest_names.unshift basename if basename != '.'
  end
  base_prefix = base_directory
  base_names = []
  while (r = chop_basename(base_prefix))
    base_prefix, basename = r
    base_names.unshift basename if basename != '.'
  end
  unless SAME_PATHS[dest_prefix, base_prefix]
    raise ArgumentError, "different prefix: #{dest_prefix.inspect} " \
    "and #{base_directory.inspect}"
  end
  while !dest_names.empty? &&
        !base_names.empty? &&
        SAME_PATHS[dest_names.first, base_names.first]
    dest_names.shift
    base_names.shift
  end
  if base_names.include? '..'
    raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
  end
  base_names.fill('..')
  relpath_names = base_names + dest_names
  if relpath_names.empty?
    Pathname.new('.')
  else
    Pathname.new(File.join(*relpath_names))
  end
end
rename(to) click to toggle source

See File.rename. Rename the file.

# File lib/fakefs/pathname.rb, line 719
def rename(to)
  File.rename(@path, to)
end
rmdir() click to toggle source

See Dir.rmdir. Remove the referenced directory.

# File lib/fakefs/pathname.rb, line 948
def rmdir
  Dir.rmdir(@path)
end
rmtree() click to toggle source

See FileUtils.rm_r. Deletes a directory and all beneath it.

# File lib/fakefs/pathname.rb, line 1000
def rmtree
  # The name "rmtree" is borrowed from File::Path of Perl.
  # File::Path provides "mkpath" and "rmtree".
  require 'fileutils'
  FileUtils.rm_r(@path)
  nil
end
root?() click to toggle source

root? is a predicate for root directories. I.e. it returns true if the pathname consists of consecutive slashes.

It doesn’t access actual filesystem. So it may return false for some pathnames which points to roots such as /usr/...

# File lib/fakefs/pathname.rb, line 192
def root?
  chop_basename(@path).nil? && /#{SEPARATOR_PAT}/o =~ @path
end
setgid?() click to toggle source

See FileTest.setgid?.

# File lib/fakefs/pathname.rb, line 864
def setgid?
  FileTest.setgid?(@path)
end
setuid?() click to toggle source

See FileTest.setuid?.

# File lib/fakefs/pathname.rb, line 859
def setuid?
  FileTest.setuid?(@path)
end
size() click to toggle source

See FileTest.size?.

# File lib/fakefs/pathname.rb, line 869
def size
  FileTest.size?(@path)
end
size?() click to toggle source

See FileTest.size?.

# File lib/fakefs/pathname.rb, line 874
def size?
  FileTest.size?(@path)
end
socket?() click to toggle source

See FileTest.socket?.

# File lib/fakefs/pathname.rb, line 834
def socket?
  FileTest.socket?(@path)
end
split() click to toggle source

See File.split. Returns the dirname and the basename in an Array.

# File lib/fakefs/pathname.rb, line 771
def split
  File.split(@path).map { |f| self.class.new(f) }
end
stat() click to toggle source

See File.stat. Returns a File::Stat object.

# File lib/fakefs/pathname.rb, line 724
def stat
  File.stat(@path)
end
sticky?() click to toggle source

See FileTest.sticky?.

# File lib/fakefs/pathname.rb, line 879
def sticky?
  FileTest.sticky?(@path)
end
sub(pattern, *rest) { |*args| ... } click to toggle source

Return a pathname which is substituted by String#sub.

# File lib/fakefs/pathname.rb, line 84
def sub(pattern, *rest, &block)
  path =
    if block
      @path.sub(pattern, *rest) do |*args|
        begin
          old = Thread.current[:pathname_sub_matchdata]
          Thread.current[:pathname_sub_matchdata] = $~
          # TODO: rewrite without using eval
          eval(
            '$~ = Thread.current[:pathname_sub_matchdata]',
            block.binding,
            __FILE__,
            __LINE__ - 3
          )
        ensure
          Thread.current[:pathname_sub_matchdata] = old
        end
        yield(*args)
      end
    else
      @path.sub(pattern, *rest)
    end
  self.class.new(path)
end
sub_ext(repl) click to toggle source

Return a pathname which the extension of the basename is substituted by repl.

If self has no extension part, repl is appended.

# File lib/fakefs/pathname.rb, line 122
def sub_ext(repl)
  ext = File.extname(@path)
  self.class.new(@path.chomp(ext) + repl)
end
sysopen(*_args) click to toggle source

See IO.sysopen. Not supported by fakefs.

# File lib/fakefs/pathname.rb, line 643
def sysopen(*_args)
  raise NotImplementedError, 'sysopen is not supported by fakefs'
end
to_s() click to toggle source

Return the path as a String.

# File lib/fakefs/pathname.rb, line 71
def to_s
  @path.dup
end
Also aliased as: TO_PATH
truncate(length) click to toggle source

See File.truncate. Truncate the file to length bytes.

# File lib/fakefs/pathname.rb, line 739
def truncate(length)
  File.truncate(@path, length)
end
utime(atime, mtime) click to toggle source

See File.utime. Update the access and modification times.

# File lib/fakefs/pathname.rb, line 744
def utime(atime, mtime)
  File.utime(atime, mtime, @path)
end
world_readable?() click to toggle source

See FileTest.world_readable?.

# File lib/fakefs/pathname.rb, line 849
def world_readable?
  FileTest.world_readable?(@path)
end
world_writable?() click to toggle source

See FileTest.world_writable?.

# File lib/fakefs/pathname.rb, line 894
def world_writable?
  FileTest.world_writable?(@path)
end
writable?() click to toggle source

See FileTest.writable?.

# File lib/fakefs/pathname.rb, line 889
def writable?
  FileTest.writable?(@path)
end
writable_real?() click to toggle source

See FileTest.writable_real?.

# File lib/fakefs/pathname.rb, line 899
def writable_real?
  FileTest.writable_real?(@path)
end
write(string, *args) click to toggle source

See File.write. Returns the number of bytes written.

# File lib/fakefs/pathname.rb, line 776
def write(string, *args)
  offset = args[0]
  open_args = args[1]
  File.open(@path, open_args || 'w') do |file|
    file.seek(offset) if offset
    return file.write(string)
  end
end
zero?() click to toggle source

See FileTest.zero?.

# File lib/fakefs/pathname.rb, line 904
def zero?
  FileTest.zero?(@path)
end

Private Instance Methods

add_trailing_separator(path) click to toggle source

add_trailing_separator(path) -> path

# File lib/fakefs/pathname.rb, line 514
def add_trailing_separator(path)
  if File.basename(path + 'a') == 'a'
    path
  else
    # xxx: Is File.join is appropriate to add separator?
    File.join(path, '')
  end
end
chop_basename(path) click to toggle source

chop_basename(path) -> [pre-basename, basename] or nil

# File lib/fakefs/pathname.rb, line 442
def chop_basename(path)
  base = File.basename(path)
  if /\A#{SEPARATOR_PAT}?\z/o =~ base
    nil
  else
    [path[0, path.rindex(base)], base]
  end
end
cleanpath_aggressive() click to toggle source

Clean the path simply by resolving and removing excess “.” and “..” entries. Nothing more, nothing less.

# File lib/fakefs/pathname.rb, line 479
def cleanpath_aggressive
  path = @path
  names = []
  pre = path
  while (r = chop_basename(pre))
    pre, base = r
    case base
    when '.' # rubocop:disable Lint/EmptyWhen
    when '..'
      names.unshift base
    else
      if names[0] == '..'
        names.shift
      else
        names.unshift base
      end
    end
  end
  if /#{SEPARATOR_PAT}/o =~ File.basename(pre)
    names.shift while names[0] == '..'
  end
  self.class.new(prepend_prefix(pre, File.join(*names)))
end
cleanpath_conservative() click to toggle source
# File lib/fakefs/pathname.rb, line 534
def cleanpath_conservative
  path = @path
  names = []
  pre = path
  while (r = chop_basename(pre))
    pre, base = r
    names.unshift base if base != '.'
  end
  if /#{SEPARATOR_PAT}/o =~ File.basename(pre)
    names.shift while names[0] == '..'
  end
  if names.empty?
    self.class.new(File.dirname(pre))
  else
    names << '.' if names.last != '..' && File.basename(path) == '.'

    result = prepend_prefix(pre, File.join(*names))
    if /\A(?:\.|\.\.)\z/ !~ names.last && trailing_separator?(path)
      self.class.new(add_trailing_separator(result))
    else
      self.class.new(result)
    end
  end
end
del_trailing_separator(path) click to toggle source
# File lib/fakefs/pathname.rb, line 523
def del_trailing_separator(path)
  if (r = chop_basename(path))
    pre, basename = r
    pre + basename
  elsif /#{SEPARATOR_PAT}+\z/o =~ path
    $` + File.dirname(path)[/#{SEPARATOR_PAT}*\z/o]
  else
    path
  end
end
plus(path1, path2) click to toggle source
# File lib/fakefs/pathname.rb, line 559
def plus(path1, path2) # -> path
  prefix2 = path2
  index_list2 = []
  basename_list2 = []
  while (r2 = chop_basename(prefix2))
    prefix2, basename2 = r2
    index_list2.unshift prefix2.length
    basename_list2.unshift basename2
  end

  return path2 if prefix2 != ''

  prefix1 = path1
  while (r1 = chop_basename(prefix1))
    while !basename_list2.empty? && basename_list2.first == '.'
      index_list2.shift
      basename_list2.shift
    end

    prefix1, basename1 = r1
    next if basename1 == '.'
    if basename1 == '..' ||
       basename_list2.empty? ||
       basename_list2.first != '..'
      prefix1 += basename1
      break
    end
    index_list2.shift
    basename_list2.shift
  end

  r1 = chop_basename(prefix1)
  if !r1 && /#{SEPARATOR_PAT}/o =~ File.basename(prefix1)
    while !basename_list2.empty? && basename_list2.first == '..'
      index_list2.shift
      basename_list2.shift
    end
  end

  if !basename_list2.empty?
    suffix2 = path2[index_list2.first..-1]
    r1 ? File.join(prefix1, suffix2) : prefix1 + suffix2
  else
    r1 ? prefix1 : File.dirname(prefix1)
  end
end
prepend_prefix(prefix, relpath) click to toggle source
# File lib/fakefs/pathname.rb, line 462
def prepend_prefix(prefix, relpath)
  if relpath.empty?
    File.dirname(prefix)
  elsif /#{SEPARATOR_PAT}/o =~ prefix
    prefix = File.dirname(prefix)
    prefix = File.join(prefix, '') if File.basename(prefix + 'a') != 'a'
    prefix + relpath
  else
    prefix + relpath
  end
end
split_names(path) click to toggle source

split_names(path) -> prefix, [name, …]

# File lib/fakefs/pathname.rb, line 452
def split_names(path)
  names = []
  while (r = chop_basename(path))
    path, basename = r
    names.unshift basename
  end

  [path, names]
end
trailing_separator?(path) click to toggle source

trailing_separator?(path) -> bool

# File lib/fakefs/pathname.rb, line 504
def trailing_separator?(path)
  if (r = chop_basename(path))
    pre, basename = r
    pre.length + basename.length < path.length
  else
    false
  end
end