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.

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

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 31
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

  self.taint if @path.tainted?
end

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 402
def +(other)
  other = Pathname.new(other) unless Pathname === other
  Pathname.new(plus(@path, other.to_s))
end
<=>(other) click to toggle source

Provides for comparing pathnames, case-sensitively.

# File lib/fakefs/pathname.rb, line 59
def <=>(other)
  return nil unless Pathname === other
  @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 51
def ==(other)
  return false unless Pathname === other
  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 309
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 382
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
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 489
def children(with_directory=true)
  with_directory = false if @path == '.'
  result = []
  Dir.foreach(@path) {|e|
    next if e == '.' || e == '..'
    if with_directory
      result << self.class.new(File.join(@path, e))
    else
      result << self.class.new(e)
    end
  }
  result
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 159
def cleanpath(consider_symlink=false)
  if consider_symlink
    cleanpath_conservative
  else
    cleanpath_aggressive
  end
end
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 355
def descend
  vs = []
  ascend {|v| vs << v }
  vs.reverse_each {|v| yield v }
  nil
end
each_child(with_directory=true, &b) 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 529
def each_child(with_directory=true, &b)
  children(with_directory).each(&b)
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 328
def each_filename # :yield: filename
  return to_enum(__method__) unless block_given?
  prefix, names = split_names(@path)
  names.each {|filename| yield filename }
  nil
end
eql?(other)
Alias for: ==
freeze() click to toggle source
Calls superclass method
# File lib/fakefs/pathname.rb, line 42
def freeze() super; @path.freeze; self end
join(*args) click to toggle source

#join joins pathnames.

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

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

mountpoint? returns true if self points to a mountpoint.

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

parent returns the parent directory.

This is same as self + '..'.

# File lib/fakefs/pathname.rb, line 280
def parent
  self + '..'
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 273
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 263
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 314
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 544
def relative_path_from(base_directory)
  dest_directory = self.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
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 303
def root?
  !!(chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o =~ @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 81
def sub(pattern, *rest, &block)
  if block
    path = @path.sub(pattern, *rest) {|*args|
      begin
        old = Thread.current[:pathname_sub_matchdata]
        Thread.current[:pathname_sub_matchdata] = $~
        eval("$~ = Thread.current[:pathname_sub_matchdata]", block.binding)
      ensure
        Thread.current[:pathname_sub_matchdata] = old
      end
      yield(*args)
    }
  else
    path = @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 111
def sub_ext(repl)
  ext = File.extname(@path)
  self.class.new(@path.chomp(ext) + repl)
end
taint() click to toggle source
Calls superclass method
# File lib/fakefs/pathname.rb, line 43
def taint() super; @path.taint; self end
to_s() click to toggle source

Return the path as a String.

# File lib/fakefs/pathname.rb, line 69
def to_s
  @path.dup
end
Also aliased as: TO_PATH
untaint() click to toggle source
Calls superclass method
# File lib/fakefs/pathname.rb, line 44
def untaint() super; @path.untaint; self end

Private Instance Methods

add_trailing_separator(path) click to toggle source

#add_trailing_separator(path) -> path

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

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

# File lib/fakefs/pathname.rb, line 117
def chop_basename(path)
  base = File.basename(path)
  if /\A#{SEPARATOR_PAT}?\z/o =~ base
    return nil
  else
    return 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 171
def cleanpath_aggressive
  path = @path
  names = []
  pre = path
  while r = chop_basename(pre)
    pre, base = r
    case base
    when '.'
    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 229
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
    if names.last != '..' && File.basename(path) == '.'
      names << '.'
    end
    result = prepend_prefix(pre, File.join(*names))
    if /\A(?:\.|\.\.)\z/ !~ names.last && has_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 217
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
has_trailing_separator?(path) click to toggle source

has_trailing_separator?(path) -> bool

# File lib/fakefs/pathname.rb, line 197
def has_trailing_separator?(path)
  if r = chop_basename(path)
    pre, basename = r
    pre.length + basename.length < path.length
  else
    false
  end
end
plus(path1, path2) click to toggle source
# File lib/fakefs/pathname.rb, line 407
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 true
    while !basename_list2.empty? && basename_list2.first == '.'
      index_list2.shift
      basename_list2.shift
    end
    break unless r1 = chop_basename(prefix1)
    prefix1, basename1 = r1
    next if basename1 == '.'
    if basename1 == '..' || basename_list2.empty? || basename_list2.first != '..'
      prefix1 = 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 138
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 128
def split_names(path)
  names = []
  while r = chop_basename(path)
    path, basename = r
    names.unshift basename
  end
  return path, names
end