524 lines
16 KiB
Ruby
524 lines
16 KiB
Ruby
# Object-Oriented Pathname Class
|
|
#
|
|
# Author:: Tanaka Akira <akr@m17n.org>
|
|
|
|
class Pathname
|
|
def initialize(path)
|
|
@path = path.to_str
|
|
end
|
|
|
|
def ==(other)
|
|
return false unless Pathname === other
|
|
other.to_s == @path
|
|
end
|
|
alias === ==
|
|
alias eql? ==
|
|
|
|
def <=>(other)
|
|
return nil unless Pathname === other
|
|
@path.tr('/', "\0") <=> other.to_s.tr('/', "\0")
|
|
end
|
|
|
|
def hash
|
|
@path.hash
|
|
end
|
|
|
|
def to_s
|
|
@path
|
|
end
|
|
alias to_str to_s
|
|
|
|
def inspect
|
|
"#<#{self.class}:#{@path}>"
|
|
end
|
|
|
|
# cleanpath returns clean pathname of self which is without consecutive
|
|
# slashes and useless dots.
|
|
#
|
|
# If true is given to the optional artument consider_symlink,
|
|
# symbolic links are considered. It makes more dots are retained.
|
|
#
|
|
# cleanpath doesn't access actual filesystem.
|
|
def cleanpath(consider_symlink=false)
|
|
if consider_symlink
|
|
cleanpath_conservative
|
|
else
|
|
cleanpath_aggressive
|
|
end
|
|
end
|
|
|
|
def cleanpath_aggressive # :nodoc:
|
|
# cleanpath_aggressive assumes:
|
|
# * no symlink
|
|
# * all pathname prefix contained in the pathname is existing directory
|
|
return Pathname.new('') if @path == ''
|
|
absolute = absolute?
|
|
names = []
|
|
@path.scan(%r{[^/]+}) {|name|
|
|
next if name == '.'
|
|
if name == '..'
|
|
if names.empty?
|
|
next if absolute
|
|
else
|
|
if names.last != '..'
|
|
names.pop
|
|
next
|
|
end
|
|
end
|
|
end
|
|
names << name
|
|
}
|
|
return Pathname.new(absolute ? '/' : '.') if names.empty?
|
|
path = absolute ? '/' : ''
|
|
path << names.join('/')
|
|
Pathname.new(path)
|
|
end
|
|
|
|
def cleanpath_conservative # :nodoc:
|
|
return Pathname.new('') if @path == ''
|
|
names = @path.scan(%r{[^/]+})
|
|
last_dot = names.last == '.'
|
|
names.delete('.')
|
|
names.shift while names.first == '..' if absolute?
|
|
return Pathname.new(absolute? ? '/' : '.') if names.empty?
|
|
path = absolute? ? '/' : ''
|
|
path << names.join('/')
|
|
if names.last != '..'
|
|
if last_dot
|
|
path << '/.'
|
|
elsif %r{/\z} =~ @path
|
|
path << '/'
|
|
end
|
|
end
|
|
Pathname.new(path)
|
|
end
|
|
|
|
# realpath returns real pathname of self in actual filesystem.
|
|
#
|
|
# If false is given for the optional argument force_absolute,
|
|
# it may return relative pathname.
|
|
# Otherwise it returns absolute pathname.
|
|
def realpath(force_absolute=true)
|
|
if relative? && force_absolute
|
|
path = File.join Dir.pwd, @path
|
|
else
|
|
path = @path
|
|
end
|
|
stats = {}
|
|
if %r{\A/} =~ path || realpath_root?('.', stats)
|
|
resolved = '/'
|
|
else
|
|
resolved = '.'
|
|
end
|
|
resolved = realpath_rec(resolved, path, stats)
|
|
Pathname.new(resolved)
|
|
end
|
|
|
|
def realpath_root?(path, stats) # :nodoc:
|
|
path_stat = stats[path] ||= File.lstat(path)
|
|
parent = path == '.' ? '..' : File.join(path, '..')
|
|
parent_stat = stats[parent] ||= File.lstat(parent)
|
|
path_stat.dev == parent_stat.dev && path_stat.ino == parent_stat.ino
|
|
end
|
|
|
|
def realpath_rec(resolved, unresolved, stats, rec={}) # :nodoc:
|
|
unresolved.scan(%r{[^/]+}) {|f|
|
|
next if f == '.'
|
|
if f == '..'
|
|
case resolved
|
|
when '/'
|
|
# Since the parent directory of '/' is '/', do nothing.
|
|
when '.'
|
|
resolved = '..'
|
|
resolved = '/' if realpath_root?(resolved, stats)
|
|
when %r{(\A|/)\.\.\z}
|
|
resolved << '/..'
|
|
resolved = '/' if realpath_root?(resolved, stats)
|
|
when %r{/}
|
|
resolved = File.dirname(resolved)
|
|
else
|
|
resolved = '.'
|
|
end
|
|
else
|
|
path = resolved == '.' ? f : File.join(resolved, f)
|
|
if File.lstat(path).symlink?
|
|
raise Errno::ELOOP.new(path) if rec.include? path
|
|
link = File.readlink path
|
|
begin
|
|
rec[path] = true
|
|
resolved = realpath_rec(resolved, link, stats, rec)
|
|
ensure
|
|
rec.delete path
|
|
end
|
|
else
|
|
resolved = path
|
|
end
|
|
end
|
|
}
|
|
resolved
|
|
end
|
|
|
|
# parent method returns parent directory, i.e. ".." is joined at last.
|
|
def parent
|
|
self.join('..')
|
|
end
|
|
|
|
# mountpoint? method returns true if self points mountpoint.
|
|
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
|
|
|
|
=begin
|
|
def rootdir?
|
|
stat1 = self.lstat
|
|
stat2 = self.parent.lstat
|
|
stat1.dev == stat2.dev && stat1.ino == stat2.ino
|
|
end
|
|
=end
|
|
|
|
# root? method is a predicate for root directory.
|
|
#
|
|
# It doesn't access actual filesystem.
|
|
# So it may return false for some pathnames
|
|
# which points root such as "/usr/..".
|
|
def root?
|
|
%r{\A/+\z} =~ @path ? true : false
|
|
end
|
|
|
|
=begin
|
|
def working_directory?
|
|
%r{\A\./*\z} =~ @path ? true : false
|
|
end
|
|
=end
|
|
|
|
# absolute? method is a predicate for absolute pathname.
|
|
# It returns true if self is beginning with a slash.
|
|
def absolute?
|
|
%r{\A/} =~ @path ? true : false
|
|
end
|
|
|
|
# relative? method is a predicate for relative pathname.
|
|
# It returns true unless self is beginning with a slash.
|
|
def relative?
|
|
!absolute?
|
|
end
|
|
|
|
# each_filename iterates over self for each filename components.
|
|
def each_filename
|
|
@path.scan(%r{[^/]+}) { yield $& }
|
|
end
|
|
|
|
# Pathname#+ return new pathname which is concatinated with self and an argument.
|
|
# If the argument is absolute pathname, it is just returned.
|
|
def +(other)
|
|
other = Pathname.new(other) unless Pathname === other
|
|
if other.absolute?
|
|
other
|
|
elsif %r{/\z} =~ @path
|
|
Pathname.new(@path + other.to_s)
|
|
else
|
|
Pathname.new(@path + '/' + other.to_s)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
# IO
|
|
class Pathname
|
|
def foreachline(*args, &block) IO.foreach(@path, *args, &block) end
|
|
def read(*args) IO.read(@path, *args) end
|
|
def readlines(*args) IO.readlines(@path, *args) end
|
|
def sysopen(*args) IO.sysopen(@path, *args) end
|
|
end
|
|
|
|
# File
|
|
class Pathname
|
|
def atime() File.atime(@path) end
|
|
def ctime() File.ctime(@path) end
|
|
def mtime() File.mtime(@path) end
|
|
def chmod(mode) File.chmod(mode, @path) end
|
|
def lchmod(mode) File.chmod(mode, @path) end
|
|
def chown(owner, group) File.chown(owner, group, @path) end
|
|
def lchown(owner, group) File.lchown(owner, group, @path) end
|
|
def fnmatch(pattern, *args) File.fnmatch(pattern, @path, *args) end
|
|
def fnmatch?(pattern, *args) File.fnmatch?(pattern, @path, *args) end
|
|
def ftype() File.ftype(@path) end
|
|
def link(old) File.link(old, @path) end
|
|
def open(*args, &block) File.open(@path, *args, &block) end
|
|
def readlink() Pathname.new(File.readlink(@path)) end
|
|
def rename(to) File.rename(@path, to) end
|
|
def stat() File.stat(@path) end
|
|
def lstat() File.lstat(@path) end
|
|
def symlink(old) File.symlink(old, @path) end
|
|
def truncate(length) File.truncate(@path, length) end
|
|
def utime(atime, mtime) File.utime(atime, mtime, @path) end
|
|
def basename(*args) Pathname.new(File.basename(@path, *args)) end
|
|
def dirname() Pathname.new(File.dirname(@path)) end
|
|
def extname() File.extname(@path) end
|
|
def expand_path(*args) Pathname.new(File.expand_path(@path, *args)) end
|
|
def join(*args) Pathname.new(File.join(@path, *args)) end
|
|
def split() File.split(@path).map {|f| Pathname.new(f) } end
|
|
end
|
|
|
|
# FileTest
|
|
class Pathname
|
|
def blockdev?() FileTest.blockdev?(@path) end
|
|
def chardev?() FileTest.chardev?(@path) end
|
|
def executable?() FileTest.executable?(@path) end
|
|
def executable_real?() FileTest.executable_real?(@path) end
|
|
def exist?() FileTest.exist?(@path) end
|
|
def grpowned?() FileTest.grpowned?(@path) end
|
|
def directory?() FileTest.directory?(@path) end
|
|
def file?() FileTest.file?(@path) end
|
|
def pipe?() FileTest.pipe?(@path) end
|
|
def socket?() FileTest.socket?(@path) end
|
|
def owned?() FileTest.owned?(@path) end
|
|
def readable?() FileTest.readable?(@path) end
|
|
def readable_real?() FileTest.readable_real?(@path) end
|
|
def setuid?() FileTest.setuid?(@path) end
|
|
def setgid?() FileTest.setgid?(@path) end
|
|
def size() FileTest.size(@path) end
|
|
def size?() FileTest.size?(@path) end
|
|
def sticky?() FileTest.sticky?(@path) end
|
|
def symlink?() FileTest.symlink?(@path) end
|
|
def writable?() FileTest.writable?(@path) end
|
|
def writable_real?() FileTest.writable_real?(@path) end
|
|
def zero?() FileTest.zero?(@path) end
|
|
end
|
|
|
|
# Dir
|
|
class Pathname
|
|
def Pathname.glob(*args)
|
|
if block_given?
|
|
Dir.glob(*args) {|f| yield Pathname.new(f) }
|
|
else
|
|
Dir.glob(*args).map {|f| Pathname.new(f) }
|
|
end
|
|
end
|
|
|
|
def Pathname.getwd() Pathname.new(Dir.getwd) end
|
|
class << self; alias pwd getwd end
|
|
|
|
def chdir(&block) Dir.chdir(@path, &block) end
|
|
def chroot() Dir.chroot(@path) end
|
|
def rmdir() Dir.rmdir(@path) end
|
|
def entries() Dir.entries(@path).map {|f| Pathname.new(f) } end
|
|
def dir_foreach(&block) Dir.foreach(@path) {|f| yield Pathname.new(f) } end
|
|
def mkdir(*args) Dir.mkdir(@path, *args) end
|
|
def opendir(&block) Dir.open(@path, &block) end
|
|
end
|
|
|
|
# Find
|
|
class Pathname
|
|
def find(&block)
|
|
require 'find'
|
|
Find.find(@path) {|f| yield Pathname.new(f) }
|
|
end
|
|
end
|
|
|
|
# FileUtils
|
|
class Pathname
|
|
def mkpath
|
|
require 'fileutils'
|
|
FileUtils.mkpath(@path)
|
|
nil
|
|
end
|
|
|
|
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
|
|
end
|
|
|
|
# mixed
|
|
class Pathname
|
|
def unlink()
|
|
if FileTest.directory? @path
|
|
Dir.unlink @path
|
|
else
|
|
File.unlink @path
|
|
end
|
|
end
|
|
alias delete unlink
|
|
|
|
def foreach(*args, &block)
|
|
if FileTest.directory? @path
|
|
# For polymorphism between Dir.foreach and IO.foreach,
|
|
# Pathname#foreach doesn't yield Pathname object.
|
|
Dir.foreach(@path, *args, &block)
|
|
else
|
|
IO.foreach(@path, *args, &block)
|
|
end
|
|
end
|
|
end
|
|
|
|
if $0 == __FILE__
|
|
require 'test/unit'
|
|
|
|
class PathnameTest < Test::Unit::TestCase # :nodoc:
|
|
class AnotherStringLike # :nodoc:
|
|
def initialize(s) @s = s end
|
|
def to_str() @s end
|
|
def ==(other) @s == other end
|
|
end
|
|
|
|
def test_equality
|
|
obj = Pathname.new("a")
|
|
str = "a"
|
|
sym = :a
|
|
ano = AnotherStringLike.new("a")
|
|
assert_equal(false, obj == str)
|
|
assert_equal(false, str == obj)
|
|
assert_equal(false, obj == ano)
|
|
assert_equal(false, ano == obj)
|
|
assert_equal(false, obj == sym)
|
|
assert_equal(false, sym == obj)
|
|
|
|
obj2 = Pathname.new("a")
|
|
assert_equal(true, obj == obj2)
|
|
assert_equal(true, obj === obj2)
|
|
assert_equal(true, obj.eql?(obj2))
|
|
end
|
|
|
|
def test_hashkey
|
|
h = {}
|
|
h[Pathname.new("a")] = 1
|
|
h[Pathname.new("a")] = 2
|
|
assert_equal(1, h.size)
|
|
end
|
|
|
|
def assert_pathname_cmp(e, s1, s2)
|
|
p1 = Pathname.new(s1)
|
|
p2 = Pathname.new(s2)
|
|
r = p1 <=> p2
|
|
assert(e == r,
|
|
"#{p1.inspect} <=> #{p2.inspect}: <#{e}> expected but was <#{r}>")
|
|
end
|
|
def test_comparison
|
|
assert_pathname_cmp( 0, "a", "a")
|
|
assert_pathname_cmp( 1, "b", "a")
|
|
assert_pathname_cmp(-1, "a", "b")
|
|
ss = %w(
|
|
a
|
|
a/
|
|
a/b
|
|
a.
|
|
a0
|
|
)
|
|
s1 = ss.shift
|
|
ss.each {|s2|
|
|
assert_pathname_cmp(-1, s1, s2)
|
|
s1 = s2
|
|
}
|
|
end
|
|
|
|
def test_comparison_string
|
|
assert_equal(nil, Pathname.new("a") <=> "a")
|
|
assert_equal(nil, "a" <=> Pathname.new("a"))
|
|
end
|
|
|
|
def test_syntactical
|
|
assert_equal(true, Pathname.new("/").root?)
|
|
assert_equal(true, Pathname.new("//").root?)
|
|
assert_equal(true, Pathname.new("///").root?)
|
|
assert_equal(false, Pathname.new("").root?)
|
|
assert_equal(false, Pathname.new("a").root?)
|
|
#assert_equal(true, Pathname.new(".").working_directory?)
|
|
#assert_equal(true, Pathname.new("./").working_directory?)
|
|
#assert_equal(true, Pathname.new(".//").working_directory?)
|
|
#assert_equal(false, Pathname.new("").working_directory?)
|
|
#assert_equal(false, Pathname.new("a").working_directory?)
|
|
end
|
|
|
|
def test_cleanpath
|
|
assert_equal('/', Pathname.new('/').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('//').cleanpath(true).to_s)
|
|
assert_equal('', Pathname.new('').cleanpath(true).to_s)
|
|
|
|
assert_equal('.', Pathname.new('.').cleanpath(true).to_s)
|
|
assert_equal('..', Pathname.new('..').cleanpath(true).to_s)
|
|
assert_equal('a', Pathname.new('a').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('/.').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('/..').cleanpath(true).to_s)
|
|
assert_equal('/a', Pathname.new('/a').cleanpath(true).to_s)
|
|
assert_equal('.', Pathname.new('./').cleanpath(true).to_s)
|
|
assert_equal('..', Pathname.new('../').cleanpath(true).to_s)
|
|
assert_equal('a/', Pathname.new('a/').cleanpath(true).to_s)
|
|
|
|
assert_equal('a/b', Pathname.new('a//b').cleanpath(true).to_s)
|
|
assert_equal('a/.', Pathname.new('a/.').cleanpath(true).to_s)
|
|
assert_equal('a/.', Pathname.new('a/./').cleanpath(true).to_s)
|
|
assert_equal('a/..', Pathname.new('a/../').cleanpath(true).to_s)
|
|
assert_equal('/a/.', Pathname.new('/a/.').cleanpath(true).to_s)
|
|
assert_equal('..', Pathname.new('./..').cleanpath(true).to_s)
|
|
assert_equal('..', Pathname.new('../.').cleanpath(true).to_s)
|
|
assert_equal('..', Pathname.new('./../').cleanpath(true).to_s)
|
|
assert_equal('..', Pathname.new('.././').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('/./..').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('/../.').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('/./../').cleanpath(true).to_s)
|
|
assert_equal('/', Pathname.new('/.././').cleanpath(true).to_s)
|
|
|
|
assert_equal('a/b/c', Pathname.new('a/b/c').cleanpath(true).to_s)
|
|
assert_equal('b/c', Pathname.new('./b/c').cleanpath(true).to_s)
|
|
assert_equal('a/c', Pathname.new('a/./c').cleanpath(true).to_s)
|
|
assert_equal('a/b/.', Pathname.new('a/b/.').cleanpath(true).to_s)
|
|
assert_equal('a/..', Pathname.new('a/../.').cleanpath(true).to_s)
|
|
|
|
assert_equal('/a', Pathname.new('/../.././../a').cleanpath(true).to_s)
|
|
assert_equal('a/b/../../../../c/../d', Pathname.new('a/b/../../../../c/../d').cleanpath(true).to_s)
|
|
end
|
|
|
|
|
|
def test_cleanpath_no_symlink
|
|
assert_equal('/', Pathname.new('/').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('//').cleanpath.to_s)
|
|
assert_equal('', Pathname.new('').cleanpath.to_s)
|
|
|
|
assert_equal('.', Pathname.new('.').cleanpath.to_s)
|
|
assert_equal('..', Pathname.new('..').cleanpath.to_s)
|
|
assert_equal('a', Pathname.new('a').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('/.').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('/..').cleanpath.to_s)
|
|
assert_equal('/a', Pathname.new('/a').cleanpath.to_s)
|
|
assert_equal('.', Pathname.new('./').cleanpath.to_s)
|
|
assert_equal('..', Pathname.new('../').cleanpath.to_s)
|
|
assert_equal('a', Pathname.new('a/').cleanpath.to_s)
|
|
|
|
assert_equal('a/b', Pathname.new('a//b').cleanpath.to_s)
|
|
assert_equal('a', Pathname.new('a/.').cleanpath.to_s)
|
|
assert_equal('a', Pathname.new('a/./').cleanpath.to_s)
|
|
assert_equal('.', Pathname.new('a/../').cleanpath.to_s)
|
|
assert_equal('/a', Pathname.new('/a/.').cleanpath.to_s)
|
|
assert_equal('..', Pathname.new('./..').cleanpath.to_s)
|
|
assert_equal('..', Pathname.new('../.').cleanpath.to_s)
|
|
assert_equal('..', Pathname.new('./../').cleanpath.to_s)
|
|
assert_equal('..', Pathname.new('.././').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('/./..').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('/../.').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('/./../').cleanpath.to_s)
|
|
assert_equal('/', Pathname.new('/.././').cleanpath.to_s)
|
|
|
|
assert_equal('a/b/c', Pathname.new('a/b/c').cleanpath.to_s)
|
|
assert_equal('b/c', Pathname.new('./b/c').cleanpath.to_s)
|
|
assert_equal('a/c', Pathname.new('a/./c').cleanpath.to_s)
|
|
assert_equal('a/b', Pathname.new('a/b/.').cleanpath.to_s)
|
|
assert_equal('.', Pathname.new('a/../.').cleanpath.to_s)
|
|
|
|
assert_equal('/a', Pathname.new('/../.././../a').cleanpath.to_s)
|
|
assert_equal('../../d', Pathname.new('a/b/../../../../c/../d').cleanpath.to_s)
|
|
end
|
|
|
|
end
|
|
end
|