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
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
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
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
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
to_path is implemented so Pathname objects are usable with File.open, etc.
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
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
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
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
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
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
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
# File lib/fakefs/pathname.rb, line 42 def freeze() super; @path.freeze; self end
#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? 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 returns the parent directory.
This is same as self + '..'
.
# File lib/fakefs/pathname.rb, line 280 def parent self + '..' end
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
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
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
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? 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
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
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
# File lib/fakefs/pathname.rb, line 43 def taint() super; @path.taint; self end
Return the path as a String.
# File lib/fakefs/pathname.rb, line 69 def to_s @path.dup end
# File lib/fakefs/pathname.rb, line 44 def untaint() super; @path.untaint; self end
Private Instance Methods
#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) -> [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
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
# 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
# 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) -> 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
# 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
# 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) -> 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