Class: Pathname
- Inherits:
-
Object
- Object
- Pathname
- Defined in:
- lib/pathname.rb,
lib/pathname.rb,
lib/pathname.rb,
ext/pathname/pathname.c
Overview
-
FileUtils *
Constant Summary collapse
- VERSION =
"0.3.0"
- TO_PATH =
to_path is implemented so Pathname objects are usable with File.open, etc.
:to_path
- SAME_PATHS =
if File::FNM_SYSCASE.nonzero? # Avoid #zero? here because #casecmp can return nil. proc {|a, b| a.casecmp(b) == 0} else proc {|a, b| a == b} end
- SEPARATOR_LIST =
"#{Regexp.quote File::SEPARATOR}"
- SEPARATOR_PAT =
/#{Regexp.quote File::SEPARATOR}/
Class Method Summary collapse
-
.getwd ⇒ Object
Returns the current working directory as a Pathname.
-
.glob(*args) ⇒ Object
Returns or yields Pathname objects.
-
.pwd ⇒ Object
Returns the current working directory as a Pathname.
Instance Method Summary collapse
-
#+(other) ⇒ Object
(also: #/)
Appends a pathname fragment to
self
to produce a new Pathname object. -
#<=>(other) ⇒ Object
Provides a case-sensitive comparison operator for pathnames.
-
#==(other) ⇒ Object
Compare this pathname with
other
. -
#===(other) ⇒ Object
Compare this pathname with
other
. -
#absolute? ⇒ Boolean
Predicate method for testing whether a path is absolute.
-
#ascend {|_self| ... } ⇒ Object
Iterates over and yields a new Pathname object for each element in the given path in ascending order.
-
#- ⇒ Object
Returns the last access time for the file.
-
#basename(*args) ⇒ Object
Returns the last component of the path.
-
#binread([length [, offset]]) ⇒ String
Returns all the bytes from the file, or the first
N
if specified. -
#binwrite(*args) ⇒ Object
Writes
contents
to the file, opening it in binary mode. -
#- ⇒ Object
Returns the birth time for the file.
-
#blockdev? ⇒ Boolean
See FileTest.blockdev?.
-
#chardev? ⇒ Boolean
See FileTest.chardev?.
-
#children(with_directory = true) ⇒ Object
Returns the children of the directory (files and subdirectories, not recursive) as an array of Pathname objects.
-
#chmod(mode_int) ⇒ Object
Changes file permissions.
-
#chown(owner_int, group_int) ⇒ Object
Change owner and group of the file.
-
#cleanpath(consider_symlink = false) ⇒ Object
Returns clean pathname of
self
with consecutive slashes and useless dots removed. -
#- ⇒ Object
Returns the last change time, using directory information, not the file itself.
-
#delete ⇒ Object
Removes a file or directory, using File.unlink if
self
is a file, or Dir.unlink as necessary. -
#descend ⇒ Object
Iterates over and yields a new Pathname object for each element in the given path in descending order.
-
#directory? ⇒ Boolean
See FileTest.directory?.
-
#dirname ⇒ Object
Returns all but the last component of the path.
-
#each_child(with_directory = true, &b) ⇒ Object
Iterates over the children of the directory (files and subdirectories, not recursive).
-
#each_entry ⇒ Object
Iterates over the entries (files and subdirectories) in the directory, yielding a Pathname object for each entry.
-
#each_filename ⇒ Object
Iterates over each component of the path.
-
#each_line(*args) ⇒ Object
Iterates over each line in the file and yields a String object for each.
-
#empty? ⇒ Boolean
Tests the file is empty.
-
#entries ⇒ Object
Return the entries (files and subdirectories) in the directory, each as a Pathname object.
-
#eql?(other) ⇒ Boolean
Compare this pathname with
other
. -
#executable? ⇒ Boolean
See FileTest.executable?.
-
#executable_real? ⇒ Boolean
See FileTest.executable_real?.
-
#exist? ⇒ Boolean
See FileTest.exist?.
-
#expand_path(*args) ⇒ Object
Returns the absolute path for the file.
-
#extname ⇒ Object
Returns the file’s extension.
-
#file? ⇒ Boolean
See FileTest.file?.
-
#find(ignore_error: true) ⇒ Object
Iterates over the directory tree in a depth first manner, yielding a Pathname for each file under “this” directory.
-
#fnmatch(*args) ⇒ Object
Return
true
if the receiver matches the given pattern. -
#fnmatch?(*args) ⇒ Object
Return
true
if the receiver matches the given pattern. -
#freeze ⇒ Object
Freezes this Pathname.
-
#- ⇒ Object
Returns “type” of file (“file”, “directory”, etc).
-
#glob(*args) ⇒ Object
Returns or yields Pathname objects.
-
#grpowned? ⇒ Boolean
See FileTest.grpowned?.
-
#hash ⇒ Object
:nodoc:.
-
#initialize(arg) ⇒ Object
constructor
Create a Pathname object from the given String (or String-like object).
-
#inspect ⇒ Object
:nodoc:.
-
#join(*args) ⇒ Object
Joins the given pathnames onto
self
to create a new Pathname object. -
#lchmod(mode_int) ⇒ Object
Same as Pathname.chmod, but does not follow symbolic links.
-
#lchown(owner_int, group_int) ⇒ Object
Same as Pathname.chown, but does not follow symbolic links.
-
#lstat ⇒ Object
See File.lstat.
-
#lutime(atime, mtime) ⇒ Object
Update the access and modification times of the file.
-
#make_link(old) ⇒ Object
Creates a hard link at pathname.
-
#make_symlink(old) ⇒ Object
Creates a symbolic link.
-
#mkdir(*args) ⇒ Object
Create the referenced directory.
-
#mkpath(mode: nil) ⇒ Object
Creates a full path, including any intermediate directories that don’t yet exist.
-
#mountpoint? ⇒ Boolean
Returns
true
ifself
points to a mountpoint. -
#- ⇒ Object
Returns the last modified time of the file.
-
#open(*args) ⇒ Object
Opens the file for reading or writing.
-
#opendir ⇒ Object
Opens the referenced directory.
-
#owned? ⇒ Boolean
See FileTest.owned?.
-
#parent ⇒ Object
Returns the parent directory.
-
#pipe? ⇒ Boolean
See FileTest.pipe?.
-
#read(*args) ⇒ Object
Returns all data from the file, or the first
N
bytes if specified. -
#readable? ⇒ Boolean
See FileTest.readable?.
-
#readable_real? ⇒ Boolean
See FileTest.readable_real?.
-
#readlines(*args) ⇒ Object
Returns all the lines from the file.
-
#readlink ⇒ Object
Read symbolic link.
-
#realdirpath(*args) ⇒ Object
Returns the real (absolute) pathname of
self
in the actual filesystem. -
#realpath(*args) ⇒ Object
Returns the real (absolute) pathname for
self
in the actual filesystem. -
#relative? ⇒ Boolean
The opposite of Pathname#absolute?.
-
#relative_path_from(base_directory) ⇒ Object
Returns a relative path from the given
base_directory
to the receiver. -
#rename(to) ⇒ Object
Rename the file.
-
#rmdir ⇒ Object
Remove the referenced directory.
-
#rmtree(noop: nil, verbose: nil, secure: nil) ⇒ Object
Recursively deletes a directory, including all directories beneath it.
-
#root? ⇒ Boolean
Predicate method for root directories.
-
#setgid? ⇒ Boolean
See FileTest.setgid?.
-
#setuid? ⇒ Boolean
See FileTest.setuid?.
-
#size ⇒ Object
See FileTest.size.
-
#size? ⇒ Boolean
See FileTest.size?.
-
#socket? ⇒ Boolean
See FileTest.socket?.
-
#split ⇒ Object
Returns the #dirname and the #basename in an Array.
-
#stat ⇒ Object
Returns a File::Stat object.
-
#sticky? ⇒ Boolean
See FileTest.sticky?.
-
#sub(*args) ⇒ Object
Return a pathname which is substituted by String#sub.
-
#sub_ext(repl) ⇒ Object
Return a pathname with
repl
added as a suffix to the basename. -
#symlink? ⇒ Boolean
See FileTest.symlink?.
-
#sysopen([mode, [perm]]) ⇒ Fixnum
See IO.sysopen.
-
#to_path ⇒ Object
Return the path as a String.
-
#to_s ⇒ Object
Return the path as a String.
-
#truncate(length) ⇒ Object
Truncates the file to
length
bytes. -
#unlink ⇒ Object
Removes a file or directory, using File.unlink if
self
is a file, or Dir.unlink as necessary. -
#utime(atime, mtime) ⇒ Object
Update the access and modification times of the file.
-
#world_readable? ⇒ Boolean
See FileTest.world_readable?.
-
#world_writable? ⇒ Boolean
See FileTest.world_writable?.
-
#writable? ⇒ Boolean
See FileTest.writable?.
-
#writable_real? ⇒ Boolean
See FileTest.writable_real?.
-
#write(*args) ⇒ Object
Writes
contents
to the file. -
#zero? ⇒ Boolean
See FileTest.zero?.
Constructor Details
#initialize(arg) ⇒ Object
Create a Pathname object from the given String (or String-like object). If path
contains a NULL character (\0
), an ArgumentError is raised.
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
# File 'ext/pathname/pathname.c', line 96
static VALUE
path_initialize(VALUE self, VALUE arg)
{
VALUE str;
if (RB_TYPE_P(arg, T_STRING)) {
str = arg;
}
else {
str = rb_check_funcall(arg, id_to_path, 0, NULL);
if (str == Qundef)
str = arg;
StringValue(str);
}
if (memchr(RSTRING_PTR(str), '\0', RSTRING_LEN(str)))
rb_raise(rb_eArgError, "pathname contains null byte");
str = rb_obj_dup(str);
set_strpath(self, str);
return self;
}
|
Class Method Details
.getwd ⇒ Object
Returns the current working directory as a Pathname.
Pathname.getwd
#=> #<Pathname:/home/zzak/projects/ruby>
See Dir.getwd.
1159 1160 1161 1162 1163 1164 1165 |
# File 'ext/pathname/pathname.c', line 1159
static VALUE
path_s_getwd(VALUE klass)
{
VALUE str;
str = rb_funcall(rb_cDir, id_getwd, 0);
return rb_class_new_instance(1, &str, klass);
}
|
.glob(*args) ⇒ Object
Returns or yields Pathname objects.
Pathname.glob("lib/i*.rb")
#=> [#<Pathname:lib/ipaddr.rb>, #<Pathname:lib/irb.rb>]
See Dir.glob.
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 |
# File 'ext/pathname/pathname.c', line 1079
static VALUE
path_s_glob(int argc, VALUE *argv, VALUE klass)
{
VALUE args[3];
int n;
n = rb_scan_args(argc, argv, "12", &args[0], &args[1], &args[2]);
if (rb_block_given_p()) {
return rb_block_call_kw(rb_cDir, id_glob, n, args, s_glob_i, klass, RB_PASS_CALLED_KEYWORDS);
}
else {
VALUE ary;
long i;
ary = rb_funcallv_kw(rb_cDir, id_glob, n, args, RB_PASS_CALLED_KEYWORDS);
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
elt = rb_class_new_instance(1, &elt, klass);
rb_ary_store(ary, i, elt);
}
return ary;
}
}
|
.pwd ⇒ Object
Returns the current working directory as a Pathname.
Pathname.getwd
#=> #<Pathname:/home/zzak/projects/ruby>
See Dir.getwd.
1159 1160 1161 1162 1163 1164 1165 |
# File 'ext/pathname/pathname.c', line 1159
static VALUE
path_s_getwd(VALUE klass)
{
VALUE str;
str = rb_funcall(rb_cDir, id_getwd, 0);
return rb_class_new_instance(1, &str, klass);
}
|
Instance Method Details
#+(other) ⇒ Object Also known as: /
Appends a pathname fragment to self
to produce a new Pathname object. Since other
is considered as a path relative to self
, if other
is an absolute path, the new Pathname object is created from just other
.
p1 = Pathname.new("/usr") # Pathname:/usr
p2 = p1 + "bin/ruby" # Pathname:/usr/bin/ruby
p3 = p1 + "/etc/passwd" # Pathname:/etc/passwd
# / is aliased to +.
p4 = p1 / "bin/ruby" # Pathname:/usr/bin/ruby
p5 = p1 / "/etc/passwd" # Pathname:/etc/passwd
This method doesn’t access the file system; it is pure string manipulation.
356 357 358 359 |
# File 'lib/pathname.rb', line 356 def +(other) other = Pathname.new(other) unless Pathname === other Pathname.new(plus(@path, other.to_s)) end |
#<=>(other) ⇒ Object
Provides a case-sensitive comparison operator for pathnames.
Pathname.new(‘/usr’) <=> Pathname.new(‘/usr/bin’)
#=> -1
Pathname.new(‘/usr/bin’) <=> Pathname.new(‘/usr/bin’)
#=> 0
Pathname.new(‘/usr/bin’) <=> Pathname.new(‘/USR/BIN’)
#=> 1
It will return -1
, 0
or 1
depending on the value of the left argument relative to the right argument. Or it will return nil
if the arguments are not comparable.
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 |
# File 'ext/pathname/pathname.c', line 160
static VALUE
path_cmp(VALUE self, VALUE other)
{
VALUE s1, s2;
char *p1, *p2;
char *e1, *e2;
if (!rb_obj_is_kind_of(other, rb_cPathname))
return Qnil;
s1 = get_strpath(self);
s2 = get_strpath(other);
p1 = RSTRING_PTR(s1);
p2 = RSTRING_PTR(s2);
e1 = p1 + RSTRING_LEN(s1);
e2 = p2 + RSTRING_LEN(s2);
while (p1 < e1 && p2 < e2) {
int c1, c2;
c1 = (unsigned char)*p1++;
c2 = (unsigned char)*p2++;
if (c1 == '/') c1 = '\0';
if (c2 == '/') c2 = '\0';
if (c1 != c2) {
if (c1 < c2)
return INT2FIX(-1);
else
return INT2FIX(1);
}
}
if (p1 < e1)
return INT2FIX(1);
if (p2 < e2)
return INT2FIX(-1);
return INT2FIX(0);
}
|
#==(other) ⇒ Object
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.
138 139 140 141 142 143 144 |
# File 'ext/pathname/pathname.c', line 138
static VALUE
path_eq(VALUE self, VALUE other)
{
if (!rb_obj_is_kind_of(other, rb_cPathname))
return Qfalse;
return rb_str_equal(get_strpath(self), get_strpath(other));
}
|
#===(other) ⇒ Object
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.
138 139 140 141 142 143 144 |
# File 'ext/pathname/pathname.c', line 138
static VALUE
path_eq(VALUE self, VALUE other)
{
if (!rb_obj_is_kind_of(other, rb_cPathname))
return Qfalse;
return rb_str_equal(get_strpath(self), get_strpath(other));
}
|
#absolute? ⇒ Boolean
233 234 235 |
# File 'lib/pathname.rb', line 233 def absolute? ABSOLUTE_PATH.match? @path end |
#ascend {|_self| ... } ⇒ Object
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>
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 /.
It doesn’t access the filesystem.
330 331 332 333 334 335 336 337 338 339 |
# File 'lib/pathname.rb', line 330 def ascend return to_enum(__method__) unless block_given? path = @path yield self while r = chop_basename(path) path, = r break if path.empty? yield self.class.new(del_trailing_separator(path)) end end |
#- ⇒ Object
Returns the last access time for the file.
See File.atime.
476 477 478 479 480 |
# File 'ext/pathname/pathname.c', line 476
static VALUE
path_atime(VALUE self)
{
return rb_funcall(rb_cFile, id_atime, 1, get_strpath(self));
}
|
#basename(*args) ⇒ Object
Returns the last component of the path.
See File.basename.
760 761 762 763 764 765 766 767 768 769 770 |
# File 'ext/pathname/pathname.c', line 760
static VALUE
path_basename(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
VALUE fext;
if (rb_scan_args(argc, argv, "01", &fext) == 0)
str = rb_funcall(rb_cFile, id_basename, 1, str);
else
str = rb_funcall(rb_cFile, id_basename, 2, str, fext);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#binread([length [, offset]]) ⇒ String
Returns all the bytes from the file, or the first N
if specified.
See File.binread.
375 376 377 378 379 380 381 382 383 384 |
# File 'ext/pathname/pathname.c', line 375
static VALUE
path_binread(int argc, VALUE *argv, VALUE self)
{
VALUE args[3];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "02", &args[1], &args[2]);
return rb_funcallv(rb_cFile, id_binread, 1+n, args);
}
|
#binwrite(string, [offset]) ⇒ Fixnum #binwrite(string, [offset], open_args) ⇒ Fixnum
Writes contents
to the file, opening it in binary mode.
See File.binwrite.
417 418 419 420 421 422 423 424 425 426 |
# File 'ext/pathname/pathname.c', line 417
static VALUE
path_binwrite(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
return rb_funcallv_kw(rb_cFile, id_binwrite, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
|
#- ⇒ Object
Returns the birth time for the file. If the platform doesn’t have birthtime, raises NotImplementedError.
See File.birthtime.
492 493 494 495 496 |
# File 'ext/pathname/pathname.c', line 492
static VALUE
path_birthtime(VALUE self)
{
return rb_funcall(rb_cFile, id_birthtime, 1, get_strpath(self));
}
|
#blockdev? ⇒ Boolean
See FileTest.blockdev?.
836 837 838 839 840 |
# File 'ext/pathname/pathname.c', line 836
static VALUE
path_blockdev_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_blockdev_p, 1, get_strpath(self));
}
|
#chardev? ⇒ Boolean
See FileTest.chardev?.
845 846 847 848 849 |
# File 'ext/pathname/pathname.c', line 845
static VALUE
path_chardev_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_chardev_p, 1, get_strpath(self));
}
|
#children(with_directory = true) ⇒ Object
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 results never contain the entries .
and ..
in the directory because they are not children.
449 450 451 452 453 454 455 456 457 458 459 460 461 |
# File 'lib/pathname.rb', line 449 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 |
#chmod(mode_int) ⇒ Object
Changes file permissions.
See File.chmod.
538 539 540 541 542 |
# File 'ext/pathname/pathname.c', line 538
static VALUE
path_chmod(VALUE self, VALUE mode)
{
return rb_funcall(rb_cFile, id_chmod, 2, mode, get_strpath(self));
}
|
#chown(owner_int, group_int) ⇒ Object
Change owner and group of the file.
See File.chown.
566 567 568 569 570 |
# File 'ext/pathname/pathname.c', line 566
static VALUE
path_chown(VALUE self, VALUE owner, VALUE group)
{
return rb_funcall(rb_cFile, id_chown, 3, owner, group, get_strpath(self));
}
|
#cleanpath(consider_symlink = false) ⇒ Object
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 Pathname#realpath.
94 95 96 97 98 99 100 |
# File 'lib/pathname.rb', line 94 def cleanpath(consider_symlink=false) if consider_symlink cleanpath_conservative else cleanpath_aggressive end end |
#- ⇒ Object
Returns the last change time, using directory information, not the file itself.
See File.ctime.
510 511 512 513 514 |
# File 'ext/pathname/pathname.c', line 510
static VALUE
path_ctime(VALUE self)
{
return rb_funcall(rb_cFile, id_ctime, 1, get_strpath(self));
}
|
#delete ⇒ Object
Removes a file or directory, using File.unlink if self
is a file, or Dir.unlink as necessary.
1287 1288 1289 1290 1291 1292 1293 |
# File 'ext/pathname/pathname.c', line 1287
static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, id_ENOTDIR);
VALUE str = get_strpath(self);
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
}
|
#descend ⇒ Object
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>
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.
It doesn’t access the filesystem.
297 298 299 300 301 302 303 |
# File 'lib/pathname.rb', line 297 def descend return to_enum(__method__) unless block_given? vs = [] ascend {|v| vs << v } vs.reverse_each {|v| yield v } nil end |
#directory? ⇒ Boolean
See FileTest.directory?.
890 891 892 893 894 |
# File 'ext/pathname/pathname.c', line 890
static VALUE
path_directory_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_directory_p, 1, get_strpath(self));
}
|
#dirname ⇒ Object
Returns all but the last component of the path.
See File.dirname.
777 778 779 780 781 782 783 |
# File 'ext/pathname/pathname.c', line 777
static VALUE
path_dirname(VALUE self)
{
VALUE str = get_strpath(self);
str = rb_funcall(rb_cFile, id_dirname, 1, str);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#each_child(with_directory = true, &b) ⇒ Object
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>
Note that the results never contain the entries .
and ..
in the directory because they are not children.
See Pathname#children
499 500 501 |
# File 'lib/pathname.rb', line 499 def each_child(with_directory=true, &b) children(with_directory).each(&b) end |
#each_entry ⇒ Object
Iterates over the entries (files and subdirectories) in the directory, yielding a Pathname object for each entry.
1261 1262 1263 1264 1265 1266 1267 1268 1269 |
# File 'ext/pathname/pathname.c', line 1261
static VALUE
path_each_entry(VALUE self)
{
VALUE args[1];
RETURN_ENUMERATOR(self, 0, 0);
args[0] = get_strpath(self);
return rb_block_call(rb_cDir, id_foreach, 1, args, each_entry_i, rb_obj_class(self));
}
|
#each_filename ⇒ Object
Iterates over each component of the path.
Pathname.new("/usr/bin/ruby").each_filename {|filename| ... }
# yields "usr", "bin", and "ruby".
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".
265 266 267 268 269 270 |
# File 'lib/pathname.rb', line 265 def each_filename # :yield: filename return to_enum(__method__) unless block_given? _, names = split_names(@path) names.each {|filename| yield filename } nil end |
#each_line {|line| ... } ⇒ Object #each_line(sep = $/[, open_args]) {|line| ... } ⇒ nil #each_line(limit[, open_args]) {|line| ... } ⇒ nil #each_line(sep, limit[, open_args]) {|line| ... } ⇒ nil #each_line(...) ⇒ Object
Iterates over each line in the file and yields a String object for each.
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 |
# File 'ext/pathname/pathname.c', line 329
static VALUE
path_each_line(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
if (rb_block_given_p()) {
return rb_block_call_kw(rb_cFile, id_foreach, 1+n, args, 0, 0, RB_PASS_CALLED_KEYWORDS);
}
else {
return rb_funcallv_kw(rb_cFile, id_foreach, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
}
|
#empty? ⇒ Boolean
Tests the file is empty.
See Dir#empty? and FileTest.empty?.
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 |
# File 'ext/pathname/pathname.c', line 1054
static VALUE
path_empty_p(VALUE self)
{
VALUE path = get_strpath(self);
if (RTEST(rb_funcall(rb_mFileTest, id_directory_p, 1, path)))
return rb_funcall(rb_cDir, id_empty_p, 1, path);
else
return rb_funcall(rb_mFileTest, id_empty_p, 1, path);
}
|
#entries ⇒ Object
Return the entries (files and subdirectories) in the directory, each as a Pathname object.
The results contains just the names in the directory, without any trailing slashes or recursive look-up.
pp Pathname.new('/usr/local').entries
#=> [#<Pathname:share>,
# #<Pathname:lib>,
# #<Pathname:..>,
# #<Pathname:include>,
# #<Pathname:etc>,
# #<Pathname:bin>,
# #<Pathname:man>,
# #<Pathname:games>,
# #<Pathname:.>,
# #<Pathname:sbin>,
# #<Pathname:src>]
The result may contain the current directory #<Pathname:.>
and the parent directory #<Pathname:..>
.
If you don’t want .
and ..
and want directories, consider Pathname#children.
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 |
# File 'ext/pathname/pathname.c', line 1193
static VALUE
path_entries(VALUE self)
{
VALUE klass, str, ary;
long i;
klass = rb_obj_class(self);
str = get_strpath(self);
ary = rb_funcall(rb_cDir, id_entries, 1, str);
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
elt = rb_class_new_instance(1, &elt, klass);
rb_ary_store(ary, i, elt);
}
return ary;
}
|
#eql?(other) ⇒ Boolean
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.
138 139 140 141 142 143 144 |
# File 'ext/pathname/pathname.c', line 138
static VALUE
path_eq(VALUE self, VALUE other)
{
if (!rb_obj_is_kind_of(other, rb_cPathname))
return Qfalse;
return rb_str_equal(get_strpath(self), get_strpath(other));
}
|
#executable? ⇒ Boolean
See FileTest.executable?.
854 855 856 857 858 |
# File 'ext/pathname/pathname.c', line 854
static VALUE
path_executable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_executable_p, 1, get_strpath(self));
}
|
#executable_real? ⇒ Boolean
See FileTest.executable_real?.
863 864 865 866 867 |
# File 'ext/pathname/pathname.c', line 863
static VALUE
path_executable_real_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_executable_real_p, 1, get_strpath(self));
}
|
#exist? ⇒ Boolean
See FileTest.exist?.
872 873 874 875 876 |
# File 'ext/pathname/pathname.c', line 872
static VALUE
path_exist_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_exist_p, 1, get_strpath(self));
}
|
#expand_path(*args) ⇒ Object
Returns the absolute path for the file.
See File.expand_path.
802 803 804 805 806 807 808 809 810 811 812 |
# File 'ext/pathname/pathname.c', line 802
static VALUE
path_expand_path(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
VALUE dname;
if (rb_scan_args(argc, argv, "01", &dname) == 0)
str = rb_funcall(rb_cFile, id_expand_path, 1, str);
else
str = rb_funcall(rb_cFile, id_expand_path, 2, str, dname);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#extname ⇒ Object
Returns the file’s extension.
See File.extname.
790 791 792 793 794 795 |
# File 'ext/pathname/pathname.c', line 790
static VALUE
path_extname(VALUE self)
{
VALUE str = get_strpath(self);
return rb_funcall(rb_cFile, id_extname, 1, str);
}
|
#file? ⇒ Boolean
See FileTest.file?.
899 900 901 902 903 |
# File 'ext/pathname/pathname.c', line 899
static VALUE
path_file_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_file_p, 1, get_strpath(self));
}
|
#find(ignore_error: true) ⇒ Object
Iterates over the directory tree in a depth first manner, yielding a Pathname for each file under “this” directory.
Returns an Enumerator if no block is given.
Since it is implemented by the standard library module Find, Find.prune can be used to control the traversal.
If self
is .
, yielded pathnames begin with a filename in the current directory, not ./
.
See Find.find
571 572 573 574 575 576 577 578 579 |
# File 'lib/pathname.rb', line 571 def find(ignore_error: true) # :yield: pathname return to_enum(__method__, ignore_error: ignore_error) unless block_given? require 'find' if @path == '.' Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) } else Find.find(@path, ignore_error: ignore_error) {|f| yield self.class.new(f) } end end |
#fnmatch(pattern, [flags]) ⇒ Boolean #fnmatch?(pattern, [flags]) ⇒ Boolean
Return true
if the receiver matches the given pattern.
See File.fnmatch.
595 596 597 598 599 600 601 602 603 604 |
# File 'ext/pathname/pathname.c', line 595
static VALUE
path_fnmatch(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
VALUE pattern, flags;
if (rb_scan_args(argc, argv, "11", &pattern, &flags) == 1)
return rb_funcall(rb_cFile, id_fnmatch, 2, pattern, str);
else
return rb_funcall(rb_cFile, id_fnmatch, 3, pattern, str, flags);
}
|
#fnmatch(pattern, [flags]) ⇒ Boolean #fnmatch?(pattern, [flags]) ⇒ Boolean
Return true
if the receiver matches the given pattern.
See File.fnmatch.
595 596 597 598 599 600 601 602 603 604 |
# File 'ext/pathname/pathname.c', line 595
static VALUE
path_fnmatch(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
VALUE pattern, flags;
if (rb_scan_args(argc, argv, "11", &pattern, &flags) == 1)
return rb_funcall(rb_cFile, id_fnmatch, 2, pattern, str);
else
return rb_funcall(rb_cFile, id_fnmatch, 3, pattern, str, flags);
}
|
#freeze ⇒ Object
Freezes this Pathname.
See Object.freeze.
125 126 127 128 129 130 131 |
# File 'ext/pathname/pathname.c', line 125
static VALUE
path_freeze(VALUE self)
{
rb_call_super(0, 0);
rb_str_freeze(get_strpath(self));
return self;
}
|
#- ⇒ Object
Returns “type” of file (“file”, “directory”, etc).
See File.ftype.
614 615 616 617 618 |
# File 'ext/pathname/pathname.c', line 614
static VALUE
path_ftype(VALUE self)
{
return rb_funcall(rb_cFile, id_ftype, 1, get_strpath(self));
}
|
#glob(*args) ⇒ Object
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 |
# File 'ext/pathname/pathname.c', line 1119
static VALUE
path_glob(int argc, VALUE *argv, VALUE self)
{
VALUE args[3];
int n;
n = rb_scan_args(argc, argv, "11", &args[0], &args[1]);
if (n == 1)
args[1] = INT2FIX(0);
args[2] = rb_hash_new();
rb_hash_aset(args[2], ID2SYM(id_base), get_strpath(self));
n = 3;
if (rb_block_given_p()) {
return rb_block_call_kw(rb_cDir, id_glob, n, args, glob_i, self, RB_PASS_KEYWORDS);
}
else {
VALUE ary;
long i;
ary = rb_funcallv_kw(rb_cDir, id_glob, n, args, RB_PASS_KEYWORDS);
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
elt = rb_funcall(self, '+', 1, elt);
rb_ary_store(ary, i, elt);
}
return ary;
}
}
|
#grpowned? ⇒ Boolean
See FileTest.grpowned?.
881 882 883 884 885 |
# File 'ext/pathname/pathname.c', line 881
static VALUE
path_grpowned_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_grpowned_p, 1, get_strpath(self));
}
|
#hash ⇒ Object
:nodoc:
199 200 201 202 203 |
# File 'ext/pathname/pathname.c', line 199
static VALUE
path_hash(VALUE self)
{
return ST2FIX(rb_str_hash(get_strpath(self)));
}
|
#inspect ⇒ Object
:nodoc:
221 222 223 224 225 226 227 |
# File 'ext/pathname/pathname.c', line 221
static VALUE
path_inspect(VALUE self)
{
const char *c = rb_obj_classname(self);
VALUE str = get_strpath(self);
return rb_sprintf("#<%s:%"PRIsVALUE">", c, str);
}
|
#join(*args) ⇒ Object
Joins the given pathnames onto self
to create a new Pathname object. This is effectively the same as using Pathname#+ to append self
and all arguments sequentially.
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
416 417 418 419 420 421 422 423 424 425 426 427 |
# File 'lib/pathname.rb', line 416 def join(*args) return self if args.empty? 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? } self + result end |
#lchmod(mode_int) ⇒ Object
Same as Pathname.chmod, but does not follow symbolic links.
See File.lchmod.
552 553 554 555 556 |
# File 'ext/pathname/pathname.c', line 552
static VALUE
path_lchmod(VALUE self, VALUE mode)
{
return rb_funcall(rb_cFile, id_lchmod, 2, mode, get_strpath(self));
}
|
#lchown(owner_int, group_int) ⇒ Object
Same as Pathname.chown, but does not follow symbolic links.
See File.lchown.
580 581 582 583 584 |
# File 'ext/pathname/pathname.c', line 580
static VALUE
path_lchown(VALUE self, VALUE owner, VALUE group)
{
return rb_funcall(rb_cFile, id_lchown, 3, owner, group, get_strpath(self));
}
|
#lstat ⇒ Object
See File.lstat.
700 701 702 703 704 |
# File 'ext/pathname/pathname.c', line 700
static VALUE
path_lstat(VALUE self)
{
return rb_funcall(rb_cFile, id_lstat, 1, get_strpath(self));
}
|
#lutime(atime, mtime) ⇒ Object
Update the access and modification times of the file.
Same as Pathname#utime, but does not follow symbolic links.
See File.lutime.
749 750 751 752 753 |
# File 'ext/pathname/pathname.c', line 749
static VALUE
path_lutime(VALUE self, VALUE atime, VALUE mtime)
{
return rb_funcall(rb_cFile, id_lutime, 3, atime, mtime, get_strpath(self));
}
|
#make_link(old) ⇒ Object
Creates a hard link at pathname.
See File.link.
628 629 630 631 632 |
# File 'ext/pathname/pathname.c', line 628
static VALUE
path_make_link(VALUE self, VALUE old)
{
return rb_funcall(rb_cFile, id_link, 2, old, get_strpath(self));
}
|
#make_symlink(old) ⇒ Object
Creates a symbolic link.
See File.symlink.
714 715 716 717 718 |
# File 'ext/pathname/pathname.c', line 714
static VALUE
path_make_symlink(VALUE self, VALUE old)
{
return rb_funcall(rb_cFile, id_symlink, 2, old, get_strpath(self));
}
|
#mkdir(*args) ⇒ Object
Create the referenced directory.
See Dir.mkdir.
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 |
# File 'ext/pathname/pathname.c', line 1215
static VALUE
path_mkdir(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
VALUE vmode;
if (rb_scan_args(argc, argv, "01", &vmode) == 0)
return rb_funcall(rb_cDir, id_mkdir, 1, str);
else
return rb_funcall(rb_cDir, id_mkdir, 2, str, vmode);
}
|
#mkpath(mode: nil) ⇒ Object
Creates a full path, including any intermediate directories that don’t yet exist.
See FileUtils.mkpath and FileUtils.mkdir_p
590 591 592 593 |
# File 'lib/pathname.rb', line 590 def mkpath(mode: nil) FileUtils.mkpath(@path, mode: mode) nil end |
#mountpoint? ⇒ Boolean
Returns true
if self
points to a mountpoint.
201 202 203 204 205 206 207 208 209 |
# File 'lib/pathname.rb', line 201 def mountpoint? begin stat1 = self.lstat stat2 = self.parent.lstat stat1.dev != stat2.dev || stat1.ino == stat2.ino rescue Errno::ENOENT false end end |
#- ⇒ Object
Returns the last modified time of the file.
See File.mtime.
524 525 526 527 528 |
# File 'ext/pathname/pathname.c', line 524
static VALUE
path_mtime(VALUE self)
{
return rb_funcall(rb_cFile, id_mtime, 1, get_strpath(self));
}
|
#open ⇒ Object #open(mode = "r"[, opt]) ⇒ File #open([mode [, perm]][, opt]) ⇒ File #open(mode = "r"[, opt]) {|file| ... } ⇒ Object #open([mode [, perm]][, opt]) {|file| ... } ⇒ Object
Opens the file for reading or writing.
See File.open.
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 |
# File 'ext/pathname/pathname.c', line 646
static VALUE
path_open(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
if (rb_block_given_p()) {
return rb_block_call_kw(rb_cFile, id_open, 1+n, args, 0, 0, RB_PASS_CALLED_KEYWORDS);
}
else {
return rb_funcallv_kw(rb_cFile, id_open, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
}
|
#opendir ⇒ Object
Opens the referenced directory.
See Dir.open.
1242 1243 1244 1245 1246 1247 1248 1249 |
# File 'ext/pathname/pathname.c', line 1242
static VALUE
path_opendir(VALUE self)
{
VALUE args[1];
args[0] = get_strpath(self);
return rb_block_call(rb_cDir, id_open, 1, args, 0, 0);
}
|
#owned? ⇒ Boolean
See FileTest.owned?.
926 927 928 929 930 |
# File 'ext/pathname/pathname.c', line 926
static VALUE
path_owned_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_owned_p, 1, get_strpath(self));
}
|
#parent ⇒ Object
Returns the parent directory.
This is same as self + '..'
.
196 197 198 |
# File 'lib/pathname.rb', line 196 def parent self + '..' end |
#pipe? ⇒ Boolean
See FileTest.pipe?.
908 909 910 911 912 |
# File 'ext/pathname/pathname.c', line 908
static VALUE
path_pipe_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_pipe_p, 1, get_strpath(self));
}
|
#read([length [, offset]]) ⇒ String #read([length [, offset]], open_args) ⇒ String
Returns all data from the file, or the first N
bytes if specified.
See File.read.
355 356 357 358 359 360 361 362 363 364 |
# File 'ext/pathname/pathname.c', line 355
static VALUE
path_read(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
return rb_funcallv_kw(rb_cFile, id_read, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
|
#readable? ⇒ Boolean
See FileTest.readable?.
935 936 937 938 939 |
# File 'ext/pathname/pathname.c', line 935
static VALUE
path_readable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_readable_p, 1, get_strpath(self));
}
|
#readable_real? ⇒ Boolean
See FileTest.readable_real?.
953 954 955 956 957 |
# File 'ext/pathname/pathname.c', line 953
static VALUE
path_readable_real_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_readable_real_p, 1, get_strpath(self));
}
|
#readlines(sep = $/[, open_args]) ⇒ Array #readlines(limit[, open_args]) ⇒ Array #readlines(sep, limit[, open_args]) ⇒ Array
Returns all the lines from the file.
See File.readlines.
439 440 441 442 443 444 445 446 447 448 |
# File 'ext/pathname/pathname.c', line 439
static VALUE
path_readlines(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
return rb_funcallv_kw(rb_cFile, id_readlines, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
|
#readlink ⇒ Object
Read symbolic link.
See File.readlink.
667 668 669 670 671 672 673 |
# File 'ext/pathname/pathname.c', line 667
static VALUE
path_readlink(VALUE self)
{
VALUE str;
str = rb_funcall(rb_cFile, id_readlink, 1, get_strpath(self));
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#realdirpath(*args) ⇒ Object
Returns the real (absolute) pathname of self
in the actual filesystem.
Does not contain symlinks or useless dots, ..
and .
.
The last component of the real pathname can be nonexistent.
310 311 312 313 314 315 316 317 |
# File 'ext/pathname/pathname.c', line 310
static VALUE
path_realdirpath(int argc, VALUE *argv, VALUE self)
{
VALUE basedir, str;
rb_scan_args(argc, argv, "01", &basedir);
str = rb_funcall(rb_cFile, id_realdirpath, 2, get_strpath(self), basedir);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#realpath(*args) ⇒ Object
Returns the real (absolute) pathname for self
in the actual filesystem.
Does not contain symlinks or useless dots, ..
and .
.
All components of the pathname must exist when this method is called.
294 295 296 297 298 299 300 301 |
# File 'ext/pathname/pathname.c', line 294
static VALUE
path_realpath(int argc, VALUE *argv, VALUE self)
{
VALUE basedir, str;
rb_scan_args(argc, argv, "01", &basedir);
str = rb_funcall(rb_cFile, id_realpath, 2, get_strpath(self), basedir);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#relative? ⇒ Boolean
248 249 250 |
# File 'lib/pathname.rb', line 248 def relative? !absolute? end |
#relative_path_from(base_directory) ⇒ Object
Returns a relative path from the given base_directory
to the receiver.
If self
is absolute, then base_directory
must be absolute too.
If self
is relative, then base_directory
must be relative too.
This method doesn’t access the filesystem. It assumes no symlinks.
ArgumentError is raised when it cannot find a relative path.
Note that this method does not handle situations where the case sensitivity of the filesystem in use differs from the operating system default.
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 |
# File 'lib/pathname.rb', line 517 def relative_path_from(base_directory) base_directory = Pathname.new(base_directory) unless base_directory.is_a? Pathname 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 |
#rename(to) ⇒ Object
Rename the file.
See File.rename.
680 681 682 683 684 |
# File 'ext/pathname/pathname.c', line 680
static VALUE
path_rename(VALUE self, VALUE to)
{
return rb_funcall(rb_cFile, id_rename, 2, get_strpath(self), to);
}
|
#rmdir ⇒ Object
Remove the referenced directory.
See Dir.rmdir.
1231 1232 1233 1234 1235 |
# File 'ext/pathname/pathname.c', line 1231
static VALUE
path_rmdir(VALUE self)
{
return rb_funcall(rb_cDir, id_rmdir, 1, get_strpath(self));
}
|
#rmtree(noop: nil, verbose: nil, secure: nil) ⇒ Object
Recursively deletes a directory, including all directories beneath it.
See FileUtils.rm_rf
598 599 600 601 602 603 604 |
# File 'lib/pathname.rb', line 598 def rmtree(noop: nil, verbose: nil, secure: nil) # The name "rmtree" is borrowed from File::Path of Perl. # File::Path provides "mkpath" and "rmtree". require 'fileutils' FileUtils.rm_rf(@path, noop: noop, verbose: verbose, secure: secure) nil end |
#root? ⇒ Boolean
Predicate method for root directories. Returns true
if the pathname consists of consecutive slashes.
It doesn’t access the filesystem. So it may return false
for some pathnames which points to roots such as /usr/..
.
218 219 220 |
# File 'lib/pathname.rb', line 218 def root? chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o.match?(@path) end |
#setgid? ⇒ Boolean
See FileTest.setgid?.
971 972 973 974 975 |
# File 'ext/pathname/pathname.c', line 971
static VALUE
path_setgid_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_setgid_p, 1, get_strpath(self));
}
|
#setuid? ⇒ Boolean
See FileTest.setuid?.
962 963 964 965 966 |
# File 'ext/pathname/pathname.c', line 962
static VALUE
path_setuid_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_setuid_p, 1, get_strpath(self));
}
|
#size ⇒ Object
See FileTest.size.
980 981 982 983 984 |
# File 'ext/pathname/pathname.c', line 980
static VALUE
path_size(VALUE self)
{
return rb_funcall(rb_mFileTest, id_size, 1, get_strpath(self));
}
|
#size? ⇒ Boolean
See FileTest.size?.
989 990 991 992 993 |
# File 'ext/pathname/pathname.c', line 989
static VALUE
path_size_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_size_p, 1, get_strpath(self));
}
|
#socket? ⇒ Boolean
See FileTest.socket?.
917 918 919 920 921 |
# File 'ext/pathname/pathname.c', line 917
static VALUE
path_socket_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_socket_p, 1, get_strpath(self));
}
|
#split ⇒ Object
Returns the #dirname and the #basename in an Array.
See File.split.
819 820 821 822 823 824 825 826 827 828 829 830 831 |
# File 'ext/pathname/pathname.c', line 819
static VALUE
path_split(VALUE self)
{
VALUE str = get_strpath(self);
VALUE ary, dirname, basename;
ary = rb_funcall(rb_cFile, id_split, 1, str);
Check_Type(ary, T_ARRAY);
dirname = rb_ary_entry(ary, 0);
basename = rb_ary_entry(ary, 1);
dirname = rb_class_new_instance(1, &dirname, rb_obj_class(self));
basename = rb_class_new_instance(1, &basename, rb_obj_class(self));
return rb_ary_new3(2, dirname, basename);
}
|
#stat ⇒ Object
Returns a File::Stat object.
See File.stat.
691 692 693 694 695 |
# File 'ext/pathname/pathname.c', line 691
static VALUE
path_stat(VALUE self)
{
return rb_funcall(rb_cFile, id_stat, 1, get_strpath(self));
}
|
#sticky? ⇒ Boolean
See FileTest.sticky?.
998 999 1000 1001 1002 |
# File 'ext/pathname/pathname.c', line 998
static VALUE
path_sticky_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_sticky_p, 1, get_strpath(self));
}
|
#sub(*args) ⇒ Object
Return a pathname which is substituted by String#sub.
path1 = Pathname.new(‘/usr/bin/perl’) path1.sub(‘perl’, ‘ruby’)
#=> #<Pathname:/usr/bin/ruby>
236 237 238 239 240 241 242 243 244 245 246 247 248 |
# File 'ext/pathname/pathname.c', line 236
static VALUE
path_sub(int argc, VALUE *argv, VALUE self)
{
VALUE str = get_strpath(self);
if (rb_block_given_p()) {
str = rb_block_call(str, id_sub, argc, argv, 0, 0);
}
else {
str = rb_funcallv(str, id_sub, argc, argv);
}
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#sub_ext(repl) ⇒ Object
Return a pathname with repl
added as a suffix to the basename.
If self has no extension part, repl
is appended.
Pathname.new(‘/usr/bin/shutdown’).sub_ext(‘.rb’)
#=> #<Pathname:/usr/bin/shutdown.rb>
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 |
# File 'ext/pathname/pathname.c', line 258
static VALUE
path_sub_ext(VALUE self, VALUE repl)
{
VALUE str = get_strpath(self);
VALUE str2;
long extlen;
const char *ext;
const char *p;
StringValue(repl);
p = RSTRING_PTR(str);
extlen = RSTRING_LEN(str);
ext = ruby_enc_find_extname(p, &extlen, rb_enc_get(str));
if (ext == NULL) {
ext = p + RSTRING_LEN(str);
}
else if (extlen <= 1) {
ext += extlen;
}
str2 = rb_str_subseq(str, 0, ext-p);
rb_str_append(str2, repl);
return rb_class_new_instance(1, &str2, rb_obj_class(self));
}
|
#symlink? ⇒ Boolean
See FileTest.symlink?.
1007 1008 1009 1010 1011 |
# File 'ext/pathname/pathname.c', line 1007
static VALUE
path_symlink_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_symlink_p, 1, get_strpath(self));
}
|
#sysopen([mode, [perm]]) ⇒ Fixnum
See IO.sysopen.
457 458 459 460 461 462 463 464 465 466 |
# File 'ext/pathname/pathname.c', line 457
static VALUE
path_sysopen(int argc, VALUE *argv, VALUE self)
{
VALUE args[3];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "02", &args[1], &args[2]);
return rb_funcallv(rb_cIO, id_sysopen, 1+n, args);
}
|
#to_s ⇒ String #to_path ⇒ String
Return the path as a String.
to_path is implemented so Pathname objects are usable with File.open, etc.
214 215 216 217 218 |
# File 'ext/pathname/pathname.c', line 214
static VALUE
path_to_s(VALUE self)
{
return rb_obj_dup(get_strpath(self));
}
|
#to_s ⇒ String #to_path ⇒ String
Return the path as a String.
to_path is implemented so Pathname objects are usable with File.open, etc.
214 215 216 217 218 |
# File 'ext/pathname/pathname.c', line 214
static VALUE
path_to_s(VALUE self)
{
return rb_obj_dup(get_strpath(self));
}
|
#truncate(length) ⇒ Object
Truncates the file to length
bytes.
See File.truncate.
725 726 727 728 729 |
# File 'ext/pathname/pathname.c', line 725
static VALUE
path_truncate(VALUE self, VALUE length)
{
return rb_funcall(rb_cFile, id_truncate, 2, get_strpath(self), length);
}
|
#unlink ⇒ Object
Removes a file or directory, using File.unlink if self
is a file, or Dir.unlink as necessary.
1287 1288 1289 1290 1291 1292 1293 |
# File 'ext/pathname/pathname.c', line 1287
static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, id_ENOTDIR);
VALUE str = get_strpath(self);
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
}
|
#utime(atime, mtime) ⇒ Object
Update the access and modification times of the file.
See File.utime.
736 737 738 739 740 |
# File 'ext/pathname/pathname.c', line 736
static VALUE
path_utime(VALUE self, VALUE atime, VALUE mtime)
{
return rb_funcall(rb_cFile, id_utime, 3, atime, mtime, get_strpath(self));
}
|
#world_readable? ⇒ Boolean
See FileTest.world_readable?.
944 945 946 947 948 |
# File 'ext/pathname/pathname.c', line 944
static VALUE
path_world_readable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_world_readable_p, 1, get_strpath(self));
}
|
#world_writable? ⇒ Boolean
See FileTest.world_writable?.
1025 1026 1027 1028 1029 |
# File 'ext/pathname/pathname.c', line 1025
static VALUE
path_world_writable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_world_writable_p, 1, get_strpath(self));
}
|
#writable? ⇒ Boolean
See FileTest.writable?.
1016 1017 1018 1019 1020 |
# File 'ext/pathname/pathname.c', line 1016
static VALUE
path_writable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_writable_p, 1, get_strpath(self));
}
|
#writable_real? ⇒ Boolean
See FileTest.writable_real?.
1034 1035 1036 1037 1038 |
# File 'ext/pathname/pathname.c', line 1034
static VALUE
path_writable_real_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_writable_real_p, 1, get_strpath(self));
}
|
#write(string, [offset]) ⇒ Fixnum #write(string, [offset], open_args) ⇒ Fixnum
Writes contents
to the file.
See File.write.
396 397 398 399 400 401 402 403 404 405 |
# File 'ext/pathname/pathname.c', line 396
static VALUE
path_write(int argc, VALUE *argv, VALUE self)
{
VALUE args[4];
int n;
args[0] = get_strpath(self);
n = rb_scan_args(argc, argv, "03", &args[1], &args[2], &args[3]);
return rb_funcallv_kw(rb_cFile, id_write, 1+n, args, RB_PASS_CALLED_KEYWORDS);
}
|
#zero? ⇒ Boolean
See FileTest.zero?.
1043 1044 1045 1046 1047 |
# File 'ext/pathname/pathname.c', line 1043
static VALUE
path_zero_p(VALUE self)
{
return rb_funcall(rb_mFileTest, id_zero_p, 1, get_strpath(self));
}
|