2015-11-10 06:48:14 -05:00
|
|
|
# frozen_string_literal: true
|
2003-12-29 17:31:55 -05:00
|
|
|
#
|
|
|
|
# = pathname.rb
|
|
|
|
#
|
2003-07-24 00:10:35 -04:00
|
|
|
# Object-Oriented Pathname Class
|
|
|
|
#
|
|
|
|
# Author:: Tanaka Akira <akr@m17n.org>
|
2003-12-29 17:31:55 -05:00
|
|
|
# Documentation:: Author and Gavin Sinclair
|
|
|
|
#
|
|
|
|
# For documentation, see class Pathname.
|
|
|
|
#
|
2003-07-24 00:10:35 -04:00
|
|
|
|
2010-07-17 00:50:19 -04:00
|
|
|
require 'pathname.so'
|
|
|
|
|
2003-07-24 00:10:35 -04:00
|
|
|
class Pathname
|
2006-06-17 01:59:29 -04:00
|
|
|
|
2017-08-03 04:11:57 -04:00
|
|
|
# :stopdoc:
|
|
|
|
|
2015-05-14 02:54:22 -04:00
|
|
|
# to_path is implemented so Pathname objects are usable with File.open, etc.
|
|
|
|
TO_PATH = :to_path
|
2009-03-28 19:59:28 -04:00
|
|
|
|
2009-10-22 20:13:02 -04:00
|
|
|
SAME_PATHS = if File::FNM_SYSCASE.nonzero?
|
2014-09-14 21:29:21 -04:00
|
|
|
# Avoid #zero? here because #casecmp can return nil.
|
|
|
|
proc {|a, b| a.casecmp(b) == 0}
|
2009-03-28 19:59:28 -04:00
|
|
|
else
|
|
|
|
proc {|a, b| a == b}
|
|
|
|
end
|
|
|
|
|
2006-06-17 01:59:29 -04:00
|
|
|
|
2005-11-26 15:43:08 -05:00
|
|
|
if File::ALT_SEPARATOR
|
2008-02-13 08:50:31 -05:00
|
|
|
SEPARATOR_LIST = "#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}"
|
|
|
|
SEPARATOR_PAT = /[#{SEPARATOR_LIST}]/
|
2005-11-26 15:43:08 -05:00
|
|
|
else
|
2008-02-13 08:50:31 -05:00
|
|
|
SEPARATOR_LIST = "#{Regexp.quote File::SEPARATOR}"
|
2005-11-26 15:43:08 -05:00
|
|
|
SEPARATOR_PAT = /#{Regexp.quote File::SEPARATOR}/
|
|
|
|
end
|
|
|
|
|
2012-09-12 09:54:08 -04:00
|
|
|
# :startdoc:
|
|
|
|
|
2005-11-26 15:43:08 -05:00
|
|
|
# chop_basename(path) -> [pre-basename, basename] or nil
|
2012-12-11 01:25:56 -05:00
|
|
|
def chop_basename(path) # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
base = File.basename(path)
|
2018-03-13 05:15:10 -04:00
|
|
|
if /\A#{SEPARATOR_PAT}?\z/o.match?(base)
|
2005-11-26 15:43:08 -05:00
|
|
|
return nil
|
|
|
|
else
|
|
|
|
return path[0, path.rindex(base)], base
|
|
|
|
end
|
|
|
|
end
|
|
|
|
private :chop_basename
|
|
|
|
|
|
|
|
# split_names(path) -> prefix, [name, ...]
|
2012-12-11 01:25:56 -05:00
|
|
|
def split_names(path) # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
names = []
|
|
|
|
while r = chop_basename(path)
|
|
|
|
path, basename = r
|
|
|
|
names.unshift basename
|
|
|
|
end
|
|
|
|
return path, names
|
|
|
|
end
|
|
|
|
private :split_names
|
|
|
|
|
2012-12-11 01:25:56 -05:00
|
|
|
def prepend_prefix(prefix, relpath) # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
if relpath.empty?
|
|
|
|
File.dirname(prefix)
|
2018-03-13 05:15:10 -04:00
|
|
|
elsif /#{SEPARATOR_PAT}/o.match?(prefix)
|
2005-11-26 15:43:08 -05:00
|
|
|
prefix = File.dirname(prefix)
|
|
|
|
prefix = File.join(prefix, "") if File.basename(prefix + 'a') != 'a'
|
|
|
|
prefix + relpath
|
|
|
|
else
|
|
|
|
prefix + relpath
|
|
|
|
end
|
|
|
|
end
|
|
|
|
private :prepend_prefix
|
|
|
|
|
2003-12-31 00:47:45 -05:00
|
|
|
# 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
|
2012-09-12 09:54:08 -04:00
|
|
|
# to avoid breaking symbolic linkages. This may retain more +..+
|
2003-12-31 00:47:45 -05:00
|
|
|
# entries than absolutely necessary, but without accessing the filesystem,
|
2012-09-12 09:54:08 -04:00
|
|
|
# this can't be avoided.
|
|
|
|
#
|
|
|
|
# See Pathname#realpath.
|
2003-07-24 00:10:35 -04:00
|
|
|
#
|
|
|
|
def cleanpath(consider_symlink=false)
|
|
|
|
if consider_symlink
|
|
|
|
cleanpath_conservative
|
|
|
|
else
|
|
|
|
cleanpath_aggressive
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Clean the path simply by resolving and removing excess +.+ and +..+ entries.
|
2003-12-31 00:47:45 -05:00
|
|
|
# Nothing more, nothing less.
|
|
|
|
#
|
2012-12-11 01:25:56 -05:00
|
|
|
def cleanpath_aggressive # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
path = @path
|
2003-07-24 00:10:35 -04:00
|
|
|
names = []
|
2005-11-26 15:43:08 -05:00
|
|
|
pre = path
|
|
|
|
while r = chop_basename(pre)
|
|
|
|
pre, base = r
|
|
|
|
case base
|
|
|
|
when '.'
|
|
|
|
when '..'
|
|
|
|
names.unshift base
|
|
|
|
else
|
|
|
|
if names[0] == '..'
|
|
|
|
names.shift
|
2003-07-24 00:10:35 -04:00
|
|
|
else
|
2005-11-26 15:43:08 -05:00
|
|
|
names.unshift base
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
end
|
2014-05-05 09:09:58 -04:00
|
|
|
pre.tr!(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
|
2018-03-13 05:15:10 -04:00
|
|
|
if /#{SEPARATOR_PAT}/o.match?(File.basename(pre))
|
2005-11-26 15:43:08 -05:00
|
|
|
names.shift while names[0] == '..'
|
|
|
|
end
|
2006-04-04 11:29:59 -04:00
|
|
|
self.class.new(prepend_prefix(pre, File.join(*names)))
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
2004-12-12 11:04:31 -05:00
|
|
|
private :cleanpath_aggressive
|
2003-07-24 00:10:35 -04:00
|
|
|
|
2005-11-26 15:43:08 -05:00
|
|
|
# has_trailing_separator?(path) -> bool
|
2012-12-11 01:25:56 -05:00
|
|
|
def has_trailing_separator?(path) # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
if r = chop_basename(path)
|
|
|
|
pre, basename = r
|
|
|
|
pre.length + basename.length < path.length
|
|
|
|
else
|
|
|
|
false
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
private :has_trailing_separator?
|
2003-07-24 00:10:35 -04:00
|
|
|
|
2005-11-26 15:43:08 -05:00
|
|
|
# add_trailing_separator(path) -> path
|
2012-12-11 01:25:56 -05:00
|
|
|
def add_trailing_separator(path) # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
if File.basename(path + 'a') == 'a'
|
|
|
|
path
|
|
|
|
else
|
|
|
|
File.join(path, "") # xxx: Is File.join is appropriate to add separator?
|
2003-11-28 01:43:51 -05:00
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
end
|
|
|
|
private :add_trailing_separator
|
|
|
|
|
2012-12-11 01:25:56 -05:00
|
|
|
def del_trailing_separator(path) # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
if r = chop_basename(path)
|
|
|
|
pre, basename = r
|
|
|
|
pre + basename
|
|
|
|
elsif /#{SEPARATOR_PAT}+\z/o =~ path
|
|
|
|
$` + File.dirname(path)[/#{SEPARATOR_PAT}*\z/o]
|
2003-10-29 03:31:43 -05:00
|
|
|
else
|
2005-11-26 15:43:08 -05:00
|
|
|
path
|
2003-10-29 03:31:43 -05:00
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
end
|
|
|
|
private :del_trailing_separator
|
|
|
|
|
2012-12-11 01:25:56 -05:00
|
|
|
def cleanpath_conservative # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
path = @path
|
|
|
|
names = []
|
|
|
|
pre = path
|
|
|
|
while r = chop_basename(pre)
|
|
|
|
pre, base = r
|
|
|
|
names.unshift base if base != '.'
|
|
|
|
end
|
2014-05-05 09:09:58 -04:00
|
|
|
pre.tr!(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
|
2018-03-13 05:15:10 -04:00
|
|
|
if /#{SEPARATOR_PAT}/o.match?(File.basename(pre))
|
2005-11-26 15:43:08 -05:00
|
|
|
names.shift while names[0] == '..'
|
|
|
|
end
|
|
|
|
if names.empty?
|
2006-04-04 11:29:59 -04:00
|
|
|
self.class.new(File.dirname(pre))
|
2005-11-26 15:43:08 -05:00
|
|
|
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)
|
2006-04-04 11:29:59 -04:00
|
|
|
self.class.new(add_trailing_separator(result))
|
2005-11-26 15:43:08 -05:00
|
|
|
else
|
2006-04-04 11:29:59 -04:00
|
|
|
self.class.new(result)
|
2005-11-26 15:43:08 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
private :cleanpath_conservative
|
2003-10-29 03:31:43 -05:00
|
|
|
|
2012-09-12 09:54:08 -04:00
|
|
|
# Returns the parent directory.
|
2003-11-07 09:28:20 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# This is same as <code>self + '..'</code>.
|
2003-07-24 00:10:35 -04:00
|
|
|
def parent
|
2003-12-21 02:28:59 -05:00
|
|
|
self + '..'
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
|
2012-09-12 09:54:08 -04:00
|
|
|
# Returns +true+ if +self+ points to a mountpoint.
|
2003-07-24 00:10:35 -04:00
|
|
|
def mountpoint?
|
|
|
|
begin
|
|
|
|
stat1 = self.lstat
|
|
|
|
stat2 = self.parent.lstat
|
2018-08-10 08:04:24 -04:00
|
|
|
stat1.dev != stat2.dev || stat1.ino == stat2.ino
|
2003-07-24 00:10:35 -04:00
|
|
|
rescue Errno::ENOENT
|
|
|
|
false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Predicate method for root directories. Returns +true+ if the
|
2003-12-31 00:47:45 -05:00
|
|
|
# pathname consists of consecutive slashes.
|
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# It doesn't access the filesystem. So it may return +false+ for some
|
2003-12-31 00:47:45 -05:00
|
|
|
# pathnames which points to roots such as <tt>/usr/..</tt>.
|
|
|
|
#
|
2003-07-24 00:10:35 -04:00
|
|
|
def root?
|
2019-12-08 10:48:13 -05:00
|
|
|
chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o.match?(@path)
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
|
2003-12-31 00:47:45 -05:00
|
|
|
# Predicate method for testing whether a path is absolute.
|
2012-09-12 09:54:08 -04:00
|
|
|
#
|
2003-12-31 00:47:45 -05:00
|
|
|
# It returns +true+ if the pathname begins with a slash.
|
2012-09-12 09:54:08 -04:00
|
|
|
#
|
|
|
|
# p = Pathname.new('/im/sure')
|
|
|
|
# p.absolute?
|
|
|
|
# #=> true
|
|
|
|
#
|
|
|
|
# p = Pathname.new('not/so/sure')
|
|
|
|
# p.absolute?
|
|
|
|
# #=> false
|
2003-07-24 00:10:35 -04:00
|
|
|
def absolute?
|
2005-11-26 15:43:08 -05:00
|
|
|
!relative?
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
|
2012-09-12 09:54:08 -04:00
|
|
|
# The opposite of Pathname#absolute?
|
|
|
|
#
|
|
|
|
# It returns +false+ if the pathname begins with a slash.
|
|
|
|
#
|
|
|
|
# p = Pathname.new('/im/sure')
|
|
|
|
# p.relative?
|
|
|
|
# #=> false
|
|
|
|
#
|
|
|
|
# p = Pathname.new('not/so/sure')
|
|
|
|
# p.relative?
|
|
|
|
# #=> true
|
2003-07-24 00:10:35 -04:00
|
|
|
def relative?
|
2005-11-26 15:43:08 -05:00
|
|
|
path = @path
|
|
|
|
while r = chop_basename(path)
|
2010-07-11 12:59:10 -04:00
|
|
|
path, = r
|
2005-11-26 15:43:08 -05:00
|
|
|
end
|
|
|
|
path == ''
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
|
|
|
# Iterates over each component of the path.
|
|
|
|
#
|
2005-07-02 12:17:17 -04:00
|
|
|
# Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
|
2003-12-31 00:47:45 -05:00
|
|
|
# # yields "usr", "bin", and "ruby".
|
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Returns an Enumerator if no block was given.
|
|
|
|
#
|
|
|
|
# enum = Pathname.new("/usr/bin/ruby").each_filename
|
|
|
|
# # ... do stuff ...
|
|
|
|
# enum.each { |e| ... }
|
|
|
|
# # yields "usr", "bin", and "ruby".
|
|
|
|
#
|
2006-06-17 01:59:29 -04:00
|
|
|
def each_filename # :yield: filename
|
2008-09-22 20:03:42 -04:00
|
|
|
return to_enum(__method__) unless block_given?
|
2010-07-11 12:59:10 -04:00
|
|
|
_, names = split_names(@path)
|
2006-02-22 07:18:58 -05:00
|
|
|
names.each {|filename| yield filename }
|
2006-06-17 01:59:29 -04:00
|
|
|
nil
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
|
2005-08-28 12:45:11 -04:00
|
|
|
# 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>
|
|
|
|
#
|
2015-06-14 11:14:46 -04:00
|
|
|
# Returns an Enumerator if no block was given.
|
|
|
|
#
|
|
|
|
# enum = Pathname.new("/usr/bin/ruby").descend
|
|
|
|
# # ... do stuff ...
|
|
|
|
# enum.each { |e| ... }
|
|
|
|
# # yields Pathnames /, /usr, /usr/bin, and /usr/bin/ruby.
|
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# It doesn't access the filesystem.
|
2006-06-17 01:59:29 -04:00
|
|
|
#
|
2005-08-28 12:45:11 -04:00
|
|
|
def descend
|
2015-06-14 11:14:46 -04:00
|
|
|
return to_enum(__method__) unless block_given?
|
2005-11-26 15:43:08 -05:00
|
|
|
vs = []
|
|
|
|
ascend {|v| vs << v }
|
|
|
|
vs.reverse_each {|v| yield v }
|
2006-04-04 11:29:59 -04:00
|
|
|
nil
|
2005-08-28 12:45:11 -04:00
|
|
|
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>
|
|
|
|
#
|
2015-06-14 11:14:46 -04:00
|
|
|
# Returns an Enumerator if no block was given.
|
|
|
|
#
|
|
|
|
# enum = Pathname.new("/usr/bin/ruby").ascend
|
|
|
|
# # ... do stuff ...
|
|
|
|
# enum.each { |e| ... }
|
|
|
|
# # yields Pathnames /usr/bin/ruby, /usr/bin, /usr, and /.
|
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# It doesn't access the filesystem.
|
2006-06-17 01:59:29 -04:00
|
|
|
#
|
2005-08-28 12:45:11 -04:00
|
|
|
def ascend
|
2015-06-14 11:14:46 -04:00
|
|
|
return to_enum(__method__) unless block_given?
|
2005-11-26 15:43:08 -05:00
|
|
|
path = @path
|
|
|
|
yield self
|
|
|
|
while r = chop_basename(path)
|
2010-07-11 12:59:10 -04:00
|
|
|
path, = r
|
2005-11-26 15:43:08 -05:00
|
|
|
break if path.empty?
|
2006-04-04 11:29:59 -04:00
|
|
|
yield self.class.new(del_trailing_separator(path))
|
2005-08-28 12:45:11 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2003-12-21 02:28:59 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Appends a pathname fragment to +self+ to produce a new Pathname object.
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
|
|
|
# p1 = Pathname.new("/usr") # Pathname:/usr
|
|
|
|
# p2 = p1 + "bin/ruby" # Pathname:/usr/bin/ruby
|
|
|
|
# p3 = p1 + "/etc/passwd" # Pathname:/etc/passwd
|
|
|
|
#
|
2014-05-05 08:49:27 -04:00
|
|
|
# # / is aliased to +.
|
|
|
|
# p4 = p1 / "bin/ruby" # Pathname:/usr/bin/ruby
|
|
|
|
# p5 = p1 / "/etc/passwd" # Pathname:/etc/passwd
|
|
|
|
#
|
2008-09-14 10:36:50 -04:00
|
|
|
# This method doesn't access the file system; it is pure string manipulation.
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2003-07-24 00:10:35 -04:00
|
|
|
def +(other)
|
|
|
|
other = Pathname.new(other) unless Pathname === other
|
2005-11-26 15:43:08 -05:00
|
|
|
Pathname.new(plus(@path, other.to_s))
|
|
|
|
end
|
2014-05-05 08:49:27 -04:00
|
|
|
alias / +
|
2003-12-21 02:28:59 -05:00
|
|
|
|
2012-12-11 01:25:56 -05:00
|
|
|
def plus(path1, path2) # -> path # :nodoc:
|
2005-11-26 15:43:08 -05:00
|
|
|
prefix2 = path2
|
|
|
|
index_list2 = []
|
|
|
|
basename_list2 = []
|
|
|
|
while r2 = chop_basename(prefix2)
|
|
|
|
prefix2, basename2 = r2
|
|
|
|
index_list2.unshift prefix2.length
|
|
|
|
basename_list2.unshift basename2
|
2003-12-21 02:28:59 -05:00
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
return path2 if prefix2 != ''
|
|
|
|
prefix1 = path1
|
|
|
|
while true
|
|
|
|
while !basename_list2.empty? && basename_list2.first == '.'
|
|
|
|
index_list2.shift
|
|
|
|
basename_list2.shift
|
2003-12-21 02:28:59 -05:00
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
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
|
2003-12-21 02:28:59 -05:00
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
r1 = chop_basename(prefix1)
|
2018-03-13 05:15:10 -04:00
|
|
|
if !r1 && (r1 = /#{SEPARATOR_PAT}/o.match?(File.basename(prefix1)))
|
2005-11-26 15:43:08 -05:00
|
|
|
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
|
2003-07-24 00:10:35 -04:00
|
|
|
else
|
2005-11-26 15:43:08 -05:00
|
|
|
r1 ? prefix1 : File.dirname(prefix1)
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
end
|
2006-04-04 11:29:59 -04:00
|
|
|
private :plus
|
2003-07-24 00:10:35 -04:00
|
|
|
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Joins the given pathnames onto +self+ to create a new Pathname object.
|
2003-11-07 09:28:20 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# path0 = Pathname.new("/usr") # Pathname:/usr
|
|
|
|
# path0 = path0.join("bin/ruby") # Pathname:/usr/bin/ruby
|
|
|
|
# # is the same as
|
|
|
|
# path1 = Pathname.new("/usr") + "bin/ruby" # Pathname:/usr/bin/ruby
|
|
|
|
# path0 == path1
|
|
|
|
# #=> true
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2003-11-07 09:28:20 -05:00
|
|
|
def join(*args)
|
2014-04-01 22:51:20 -04:00
|
|
|
return self if args.empty?
|
2003-12-21 02:28:59 -05:00
|
|
|
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?
|
|
|
|
}
|
2014-03-25 10:42:36 -04:00
|
|
|
self + result
|
2003-11-07 09:28:20 -05:00
|
|
|
end
|
|
|
|
|
2003-10-13 15:46:07 -04:00
|
|
|
#
|
2003-12-31 00:47:45 -05:00
|
|
|
# Returns the children of the directory (files and subdirectories, not
|
2012-09-12 09:54:08 -04:00
|
|
|
# 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.
|
2003-10-13 15:46:07 -04:00
|
|
|
#
|
2003-12-31 00:47:45 -05:00
|
|
|
# For example:
|
2009-01-31 00:18:25 -05:00
|
|
|
# pn = Pathname("/usr/lib/ruby/1.8")
|
|
|
|
# pn.children
|
2003-12-31 00:47:45 -05:00
|
|
|
# # -> [ Pathname:/usr/lib/ruby/1.8/English.rb,
|
|
|
|
# Pathname:/usr/lib/ruby/1.8/Env.rb,
|
|
|
|
# Pathname:/usr/lib/ruby/1.8/abbrev.rb, ... ]
|
2009-01-31 00:18:25 -05:00
|
|
|
# pn.children(false)
|
2003-12-31 00:47:45 -05:00
|
|
|
# # -> [ Pathname:English.rb, Pathname:Env.rb, Pathname:abbrev.rb, ... ]
|
2003-11-07 09:28:20 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Note that the results never contain the entries +.+ and +..+ in
|
2003-12-31 00:47:45 -05:00
|
|
|
# the directory because they are not children.
|
|
|
|
#
|
2003-11-07 09:28:20 -05:00
|
|
|
def children(with_directory=true)
|
|
|
|
with_directory = false if @path == '.'
|
2003-10-13 15:46:07 -04:00
|
|
|
result = []
|
|
|
|
Dir.foreach(@path) {|e|
|
|
|
|
next if e == '.' || e == '..'
|
2003-11-07 09:28:20 -05:00
|
|
|
if with_directory
|
2006-04-04 11:29:59 -04:00
|
|
|
result << self.class.new(File.join(@path, e))
|
2003-10-13 15:46:07 -04:00
|
|
|
else
|
2006-04-04 11:29:59 -04:00
|
|
|
result << self.class.new(e)
|
2003-10-13 15:46:07 -04:00
|
|
|
end
|
|
|
|
}
|
|
|
|
result
|
2003-10-03 12:36:24 -04:00
|
|
|
end
|
|
|
|
|
2009-01-31 00:13:49 -05:00
|
|
|
# Iterates over the children of the directory
|
|
|
|
# (files and subdirectories, not recursive).
|
2012-09-12 09:54:08 -04:00
|
|
|
#
|
2009-01-31 00:13:49 -05:00
|
|
|
# It yields Pathname object for each child.
|
2012-09-12 09:54:08 -04:00
|
|
|
#
|
|
|
|
# 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.
|
2009-01-31 00:13:49 -05:00
|
|
|
#
|
|
|
|
# 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>
|
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Note that the results never contain the entries +.+ and +..+ in
|
|
|
|
# the directory because they are not children.
|
|
|
|
#
|
|
|
|
# See Pathname#children
|
|
|
|
#
|
2009-01-31 00:13:49 -05:00
|
|
|
def each_child(with_directory=true, &b)
|
|
|
|
children(with_directory).each(&b)
|
|
|
|
end
|
|
|
|
|
2003-10-04 02:04:59 -04:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Returns a relative path from the given +base_directory+ to the receiver.
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# If +self+ is absolute, then +base_directory+ must be absolute too.
|
2003-10-04 02:04:59 -04:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# If +self+ is relative, then +base_directory+ must be relative too.
|
2003-10-04 02:04:59 -04:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# This method doesn't access the filesystem. It assumes no symlinks.
|
|
|
|
#
|
|
|
|
# ArgumentError is raised when it cannot find a relative path.
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2003-10-04 02:04:59 -04:00
|
|
|
def relative_path_from(base_directory)
|
2018-12-17 22:09:54 -05:00
|
|
|
base_directory = Pathname.new(base_directory) unless base_directory.is_a? Pathname
|
2005-11-26 15:43:08 -05:00
|
|
|
dest_directory = self.cleanpath.to_s
|
2018-12-17 22:09:54 -05:00
|
|
|
base_directory = base_directory.cleanpath.to_s
|
2005-11-26 15:43:08 -05:00
|
|
|
dest_prefix = dest_directory
|
|
|
|
dest_names = []
|
|
|
|
while r = chop_basename(dest_prefix)
|
|
|
|
dest_prefix, basename = r
|
|
|
|
dest_names.unshift basename if basename != '.'
|
2003-10-04 02:04:59 -04:00
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
base_prefix = base_directory
|
|
|
|
base_names = []
|
|
|
|
while r = chop_basename(base_prefix)
|
|
|
|
base_prefix, basename = r
|
|
|
|
base_names.unshift basename if basename != '.'
|
2003-10-04 02:04:59 -04:00
|
|
|
end
|
2009-03-28 19:59:28 -04:00
|
|
|
unless SAME_PATHS[dest_prefix, base_prefix]
|
2005-11-26 15:43:08 -05:00
|
|
|
raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
|
|
|
|
end
|
|
|
|
while !dest_names.empty? &&
|
|
|
|
!base_names.empty? &&
|
2009-03-28 19:59:28 -04:00
|
|
|
SAME_PATHS[dest_names.first, base_names.first]
|
2005-11-26 15:43:08 -05:00
|
|
|
dest_names.shift
|
|
|
|
base_names.shift
|
|
|
|
end
|
|
|
|
if base_names.include? '..'
|
2003-10-04 02:04:59 -04:00
|
|
|
raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
|
|
|
|
end
|
2005-11-26 15:43:08 -05:00
|
|
|
base_names.fill('..')
|
|
|
|
relpath_names = base_names + dest_names
|
|
|
|
if relpath_names.empty?
|
|
|
|
Pathname.new('.')
|
2003-10-04 02:04:59 -04:00
|
|
|
else
|
2005-11-26 15:43:08 -05:00
|
|
|
Pathname.new(File.join(*relpath_names))
|
2003-10-04 02:04:59 -04:00
|
|
|
end
|
|
|
|
end
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
|
2003-12-29 17:31:55 -05:00
|
|
|
|
|
|
|
class Pathname # * Find *
|
2003-11-07 09:28:20 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Iterates over the directory tree in a depth first manner, yielding a
|
|
|
|
# Pathname for each file under "this" directory.
|
2003-11-07 09:28:20 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Returns an Enumerator if no block is given.
|
2011-11-19 07:52:37 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# Since it is implemented by the standard library module Find, Find.prune can
|
|
|
|
# be used to control the traversal.
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2012-09-12 09:54:08 -04:00
|
|
|
# If +self+ is +.+, yielded pathnames begin with a filename in the
|
|
|
|
# current directory, not +./+.
|
|
|
|
#
|
|
|
|
# See Find.find
|
2003-12-31 00:47:45 -05:00
|
|
|
#
|
2014-03-04 10:44:53 -05:00
|
|
|
def find(ignore_error: true) # :yield: pathname
|
|
|
|
return to_enum(__method__, ignore_error: ignore_error) unless block_given?
|
2003-07-24 00:10:35 -04:00
|
|
|
require 'find'
|
2003-11-07 09:28:20 -05:00
|
|
|
if @path == '.'
|
2014-03-04 10:44:53 -05:00
|
|
|
Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) }
|
2003-11-07 09:28:20 -05:00
|
|
|
else
|
2014-03-04 10:44:53 -05:00
|
|
|
Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f) }
|
2003-11-07 09:28:20 -05:00
|
|
|
end
|
2003-07-24 00:10:35 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2003-12-29 17:31:55 -05:00
|
|
|
|
|
|
|
class Pathname # * FileUtils *
|
2012-09-12 09:54:08 -04:00
|
|
|
# Creates a full path, including any intermediate directories that don't yet
|
|
|
|
# exist.
|
|
|
|
#
|
|
|
|
# See FileUtils.mkpath and FileUtils.mkdir_p
|
2003-07-24 00:10:35 -04:00
|
|
|
def mkpath
|
|
|
|
require 'fileutils'
|
|
|
|
FileUtils.mkpath(@path)
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
|
2012-09-12 09:54:08 -04:00
|
|
|
# Recursively deletes a directory, including all directories beneath it.
|
|
|
|
#
|
|
|
|
# See FileUtils.rm_r
|
2003-07-24 00:10:35 -04:00
|
|
|
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
|
|
|
|
|