Class: Pathname
- Inherits:
-
Object
- Object
- Pathname
- Defined in:
- lib/pathname.rb,
lib/pathname.rb,
lib/pathname.rb,
pathname.c
Overview
-
FileUtils *
Constant Summary collapse
- TO_PATH =
to_path is implemented so Pathname objects are usable with File.open, etc.
:to_path
- SAME_PATHS =
if File::FNM_SYSCASE.nonzero? proc {|a, b| a.casecmp(b).zero?} 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 ⇒ Object
Returns or yields Pathname objects.
-
.pwd ⇒ Object
Returns the current working directory as a Pathname.
Instance Method Summary collapse
-
#+(other) ⇒ Object
Appends a pathname fragment to
self
to produce a new Pathname object. -
#<=> ⇒ Object
Provides a case-sensitive comparison operator for pathnames.
-
#== ⇒ Object
Compare this pathname with
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 ⇒ 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. -
#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.
-
#- ⇒ Object
Changes file permissions.
-
#- ⇒ 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 ⇒ Object
Iterates over each line in the file and yields a String object for each.
-
#entries ⇒ Object
Return the entries (files and subdirectories) in the directory, each as a Pathname object.
-
#eql? ⇒ 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 ⇒ Object
Returns the absolute path for the file.
-
#extname ⇒ Object
Returns the file’s extension.
-
#file? ⇒ Boolean
See FileTest.file?.
-
#find ⇒ Object
Iterates over the directory tree in a depth first manner, yielding a Pathname for each file under “this” directory.
-
#fnmatch ⇒ Object
Return
true
if the receiver matches the given pattern. -
#fnmatch? ⇒ Boolean
Return
true
if the receiver matches the given pattern. -
#freeze ⇒ Object
Freezes this Pathname.
-
#- ⇒ Object
Returns “type” of file (“file”, “directory”, etc).
-
#grpowned? ⇒ Boolean
See FileTest.grpowned?.
-
#hash ⇒ Object
:nodoc:.
-
#initialize ⇒ 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. -
#- ⇒ Object
Same as Pathname.chmod, but does not follow symbolic links.
-
#- ⇒ Object
Same as Pathname.chown, but does not follow symbolic links.
-
#lstat ⇒ Object
See File.lstat.
-
#make_link(old) ⇒ Object
Creates a hard link at pathname.
-
#make_symlink(old) ⇒ Object
Creates a symbolic link.
-
#mkdir ⇒ Object
Create the referenced directory.
-
#mkpath ⇒ 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 ⇒ 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 ⇒ 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 ⇒ Object
Returns all the lines from the file.
-
#readlink ⇒ Object
Read symbolic link.
-
#realdirpath ⇒ Object
Returns the real (absolute) pathname of
self
in the actual filesystem. -
#realpath ⇒ 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 ⇒ Object
Rename the file.
-
#rmdir ⇒ Object
Remove the referenced directory.
-
#rmtree ⇒ 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 ⇒ Object
Return a pathname which is substituted by String#sub.
-
#sub_ext ⇒ 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.
-
#taint ⇒ Object
Taints this Pathname.
-
#to_path ⇒ Object
Return the path as a String.
-
#to_s ⇒ Object
Return the path as a String.
-
#truncate ⇒ 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. -
#untaint ⇒ Object
Untaints this Pathname.
-
#utime ⇒ 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?.
-
#zero? ⇒ Boolean
See FileTest.zero?.
Constructor Details
#initialize ⇒ Object
Create a Pathname object from the given String (or String-like object). If path
contains a NULL character (\0
), an ArgumentError is raised.
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
# File 'pathname.c', line 27
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);
OBJ_INFECT(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.
974 975 976 977 978 979 980 |
# File 'pathname.c', line 974
static VALUE
path_s_getwd(VALUE klass)
{
VALUE str;
str = rb_funcall(rb_cDir, rb_intern("getwd"), 0);
return rb_class_new_instance(1, &str, klass);
}
|
.glob ⇒ Object
Returns or yields Pathname objects.
Pathname.glob("config/" "*.rb")
#=> [#<Pathname:config/environment.rb>, #<Pathname:config/routes.rb>, ..]
See Dir.glob.
942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 |
# File 'pathname.c', line 942
static VALUE
path_s_glob(int argc, VALUE *argv, VALUE klass)
{
VALUE args[2];
int n;
n = rb_scan_args(argc, argv, "11", &args[0], &args[1]);
if (rb_block_given_p()) {
return rb_block_call(rb_cDir, rb_intern("glob"), n, args, glob_i, klass);
}
else {
VALUE ary;
long i;
ary = rb_funcall2(rb_cDir, rb_intern("glob"), n, args);
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_PTR(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.
974 975 976 977 978 979 980 |
# File 'pathname.c', line 974
static VALUE
path_s_getwd(VALUE klass)
{
VALUE str;
str = rb_funcall(rb_cDir, rb_intern("getwd"), 0);
return rb_class_new_instance(1, &str, klass);
}
|
Instance Method Details
#+(other) ⇒ Object
329 330 331 332 |
# File 'lib/pathname.rb', line 329 def +(other) other = Pathname.new(other) unless Pathname === other Pathname.new(plus(@path, other.to_s)) end |
#<=> ⇒ 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.
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 |
# File 'pathname.c', line 124
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);
}
|
#== ⇒ 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.
102 103 104 105 106 107 108 |
# File 'pathname.c', line 102
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));
}
|
#=== ⇒ 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.
102 103 104 105 106 107 108 |
# File 'pathname.c', line 102
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
224 225 226 |
# File 'lib/pathname.rb', line 224 def absolute? !relative? 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>
It doesn’t access the filesystem.
310 311 312 313 314 315 316 317 318 |
# File 'lib/pathname.rb', line 310 def ascend 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.
395 396 397 398 399 |
# File 'pathname.c', line 395
static VALUE
path_atime(VALUE self)
{
return rb_funcall(rb_cFile, rb_intern("atime"), 1, get_strpath(self));
}
|
#basename ⇒ Object
Returns the last component of the path.
See File.basename.
639 640 641 642 643 644 645 646 647 648 649 |
# File 'pathname.c', line 639
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, rb_intern("basename"), 1, str);
else
str = rb_funcall(rb_cFile, rb_intern("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 IO.binread.
336 337 338 339 340 341 342 343 344 345 |
# File 'pathname.c', line 336
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_funcall2(rb_cIO, rb_intern("binread"), 1+n, args);
}
|
#blockdev? ⇒ Boolean
See FileTest.blockdev?.
715 716 717 718 719 |
# File 'pathname.c', line 715
static VALUE
path_blockdev_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("blockdev?"), 1, get_strpath(self));
}
|
#chardev? ⇒ Boolean
See FileTest.chardev?.
724 725 726 727 728 |
# File 'pathname.c', line 724
static VALUE
path_chardev_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("chardev?"), 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.
419 420 421 422 423 424 425 426 427 428 429 430 431 |
# File 'lib/pathname.rb', line 419 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 |
#- ⇒ Object
Changes file permissions.
See File.chmod.
437 438 439 440 441 |
# File 'pathname.c', line 437
static VALUE
path_chmod(VALUE self, VALUE mode)
{
return rb_funcall(rb_cFile, rb_intern("chmod"), 2, mode, get_strpath(self));
}
|
#- ⇒ Object
Change owner and group of the file.
See File.chown.
465 466 467 468 469 |
# File 'pathname.c', line 465
static VALUE
path_chown(VALUE self, VALUE owner, VALUE group)
{
return rb_funcall(rb_cFile, rb_intern("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.
86 87 88 89 90 91 92 |
# File 'lib/pathname.rb', line 86 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.
409 410 411 412 413 |
# File 'pathname.c', line 409
static VALUE
path_ctime(VALUE self)
{
return rb_funcall(rb_cFile, rb_intern("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.
1101 1102 1103 1104 1105 1106 1107 |
# File 'pathname.c', line 1101
static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, rb_intern("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>
It doesn’t access the filesystem.
285 286 287 288 289 290 |
# File 'lib/pathname.rb', line 285 def descend vs = [] ascend {|v| vs << v } vs.reverse_each {|v| yield v } nil end |
#directory? ⇒ Boolean
See FileTest.directory?.
769 770 771 772 773 |
# File 'pathname.c', line 769
static VALUE
path_directory_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("directory?"), 1, get_strpath(self));
}
|
#dirname ⇒ Object
Returns all but the last component of the path.
See File.dirname.
656 657 658 659 660 661 662 |
# File 'pathname.c', line 656
static VALUE
path_dirname(VALUE self)
{
VALUE str = get_strpath(self);
str = rb_funcall(rb_cFile, rb_intern("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
469 470 471 |
# File 'lib/pathname.rb', line 469 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.
1076 1077 1078 1079 1080 1081 1082 1083 |
# File 'pathname.c', line 1076
static VALUE
path_each_entry(VALUE self)
{
VALUE args[1];
args[0] = get_strpath(self);
return rb_block_call(rb_cDir, rb_intern("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".
260 261 262 263 264 265 |
# File 'lib/pathname.rb', line 260 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.
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 |
# File 'pathname.c', line 290
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(rb_cIO, rb_intern("foreach"), 1+n, args, 0, 0);
}
else {
return rb_funcall2(rb_cIO, rb_intern("foreach"), 1+n, args);
}
}
|
#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.
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 |
# File 'pathname.c', line 1008
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, rb_intern("entries"), 1, str);
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_PTR(ary)[i];
elt = rb_class_new_instance(1, &elt, klass);
rb_ary_store(ary, i, elt);
}
return ary;
}
|
#eql? ⇒ 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.
102 103 104 105 106 107 108 |
# File 'pathname.c', line 102
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?.
733 734 735 736 737 |
# File 'pathname.c', line 733
static VALUE
path_executable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("executable?"), 1, get_strpath(self));
}
|
#executable_real? ⇒ Boolean
See FileTest.executable_real?.
742 743 744 745 746 |
# File 'pathname.c', line 742
static VALUE
path_executable_real_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("executable_real?"), 1, get_strpath(self));
}
|
#exist? ⇒ Boolean
See FileTest.exist?.
751 752 753 754 755 |
# File 'pathname.c', line 751
static VALUE
path_exist_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("exist?"), 1, get_strpath(self));
}
|
#expand_path ⇒ Object
Returns the absolute path for the file.
See File.expand_path.
681 682 683 684 685 686 687 688 689 690 691 |
# File 'pathname.c', line 681
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, rb_intern("expand_path"), 1, str);
else
str = rb_funcall(rb_cFile, rb_intern("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.
669 670 671 672 673 674 |
# File 'pathname.c', line 669
static VALUE
path_extname(VALUE self)
{
VALUE str = get_strpath(self);
return rb_funcall(rb_cFile, rb_intern("extname"), 1, str);
}
|
#file? ⇒ Boolean
See FileTest.file?.
778 779 780 781 782 |
# File 'pathname.c', line 778
static VALUE
path_file_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("file?"), 1, get_strpath(self));
}
|
#find ⇒ 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
537 538 539 540 541 542 543 544 545 |
# File 'lib/pathname.rb', line 537 def find # :yield: pathname return to_enum(__method__) unless block_given? require 'find' if @path == '.' Find.find(@path) {|f| yield self.class.new(f.sub(%r{\A\./}, '')) } else Find.find(@path) {|f| yield self.class.new(f) } end end |
#fnmatch(pattern, [flags]) ⇒ String #fnmatch?(pattern, [flags]) ⇒ String
Return true
if the receiver matches the given pattern.
See File.fnmatch.
494 495 496 497 498 499 500 501 502 503 |
# File 'pathname.c', line 494
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, rb_intern("fnmatch"), 2, pattern, str);
else
return rb_funcall(rb_cFile, rb_intern("fnmatch"), 3, pattern, str, flags);
}
|
#fnmatch(pattern, [flags]) ⇒ String #fnmatch?(pattern, [flags]) ⇒ String
Return true
if the receiver matches the given pattern.
See File.fnmatch.
494 495 496 497 498 499 500 501 502 503 |
# File 'pathname.c', line 494
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, rb_intern("fnmatch"), 2, pattern, str);
else
return rb_funcall(rb_cFile, rb_intern("fnmatch"), 3, pattern, str, flags);
}
|
#freeze ⇒ Object
Freezes this Pathname.
See Object.freeze.
57 58 59 60 61 62 63 |
# File 'pathname.c', line 57
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.
513 514 515 516 517 |
# File 'pathname.c', line 513
static VALUE
path_ftype(VALUE self)
{
return rb_funcall(rb_cFile, rb_intern("ftype"), 1, get_strpath(self));
}
|
#grpowned? ⇒ Boolean
See FileTest.grpowned?.
760 761 762 763 764 |
# File 'pathname.c', line 760
static VALUE
path_grpowned_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("grpowned?"), 1, get_strpath(self));
}
|
#hash ⇒ Object
:nodoc:
159 160 161 162 163 |
# File 'pathname.c', line 159
static VALUE
path_hash(VALUE self)
{
return INT2FIX(rb_str_hash(get_strpath(self)));
}
|
#inspect ⇒ Object
:nodoc:
181 182 183 184 185 186 187 |
# File 'pathname.c', line 181
static VALUE
path_inspect(VALUE self)
{
const char *c = rb_obj_classname(self);
VALUE str = get_strpath(self);
return rb_sprintf("#<%s:%s>", c, RSTRING_PTR(str));
}
|
#join(*args) ⇒ Object
386 387 388 389 390 391 392 393 394 395 396 397 |
# File 'lib/pathname.rb', line 386 def join(*args) args.unshift self result = args.pop result = Pathname.new(result) unless Pathname === result return result if result.absolute? args.reverse_each {|arg| arg = Pathname.new(arg) unless Pathname === arg result = arg + result return result if result.absolute? } result end |
#- ⇒ Object
Same as Pathname.chmod, but does not follow symbolic links.
See File.lchmod.
451 452 453 454 455 |
# File 'pathname.c', line 451
static VALUE
path_lchmod(VALUE self, VALUE mode)
{
return rb_funcall(rb_cFile, rb_intern("lchmod"), 2, mode, get_strpath(self));
}
|
#- ⇒ Object
Same as Pathname.chown, but does not follow symbolic links.
See File.lchown.
479 480 481 482 483 |
# File 'pathname.c', line 479
static VALUE
path_lchown(VALUE self, VALUE owner, VALUE group)
{
return rb_funcall(rb_cFile, rb_intern("lchown"), 3, owner, group, get_strpath(self));
}
|
#lstat ⇒ Object
See File.lstat.
592 593 594 595 596 |
# File 'pathname.c', line 592
static VALUE
path_lstat(VALUE self)
{
return rb_funcall(rb_cFile, rb_intern("lstat"), 1, get_strpath(self));
}
|
#make_link(old) ⇒ Object
Creates a hard link at pathname.
See File.link.
527 528 529 530 531 |
# File 'pathname.c', line 527
static VALUE
path_make_link(VALUE self, VALUE old)
{
return rb_funcall(rb_cFile, rb_intern("link"), 2, old, get_strpath(self));
}
|
#make_symlink(old) ⇒ Object
Creates a symbolic link.
See File.symlink.
606 607 608 609 610 |
# File 'pathname.c', line 606
static VALUE
path_make_symlink(VALUE self, VALUE old)
{
return rb_funcall(rb_cFile, rb_intern("symlink"), 2, old, get_strpath(self));
}
|
#mkdir ⇒ Object
Create the referenced directory.
See Dir.mkdir.
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 |
# File 'pathname.c', line 1030
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, rb_intern("mkdir"), 1, str);
else
return rb_funcall(rb_cDir, rb_intern("mkdir"), 2, str, vmode);
}
|
#mkpath ⇒ Object
Creates a full path, including any intermediate directories that don’t yet exist.
See FileUtils.mkpath and FileUtils.mkdir_p
554 555 556 557 558 |
# File 'lib/pathname.rb', line 554 def mkpath require 'fileutils' FileUtils.mkpath(@path) nil end |
#mountpoint? ⇒ Boolean
Returns true
if self
points to a mountpoint.
191 192 193 194 195 196 197 198 199 200 |
# File 'lib/pathname.rb', line 191 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 |
#- ⇒ Object
Returns the last modified time of the file.
See File.mtime.
423 424 425 426 427 |
# File 'pathname.c', line 423
static VALUE
path_mtime(VALUE self)
{
return rb_funcall(rb_cFile, rb_intern("mtime"), 1, get_strpath(self));
}
|
#open ⇒ Object
Opens the file for reading or writing.
See File.open.
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 |
# File 'pathname.c', line 538
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(rb_cFile, rb_intern("open"), 1+n, args, 0, 0);
}
else {
return rb_funcall2(rb_cFile, rb_intern("open"), 1+n, args);
}
}
|
#opendir ⇒ Object
Opens the referenced directory.
See Dir.open.
1057 1058 1059 1060 1061 1062 1063 1064 |
# File 'pathname.c', line 1057
static VALUE
path_opendir(VALUE self)
{
VALUE args[1];
args[0] = get_strpath(self);
return rb_block_call(rb_cDir, rb_intern("open"), 1, args, 0, 0);
}
|
#owned? ⇒ Boolean
See FileTest.owned?.
805 806 807 808 809 |
# File 'pathname.c', line 805
static VALUE
path_owned_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("owned?"), 1, get_strpath(self));
}
|
#parent ⇒ Object
Returns the parent directory.
This is same as self + '..'
.
186 187 188 |
# File 'lib/pathname.rb', line 186 def parent self + '..' end |
#pipe? ⇒ Boolean
See FileTest.pipe?.
787 788 789 790 791 |
# File 'pathname.c', line 787
static VALUE
path_pipe_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("pipe?"), 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 IO.read.
316 317 318 319 320 321 322 323 324 325 |
# File 'pathname.c', line 316
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_funcall2(rb_cIO, rb_intern("read"), 1+n, args);
}
|
#readable? ⇒ Boolean
See FileTest.readable?.
814 815 816 817 818 |
# File 'pathname.c', line 814
static VALUE
path_readable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("readable?"), 1, get_strpath(self));
}
|
#readable_real? ⇒ Boolean
See FileTest.readable_real?.
832 833 834 835 836 |
# File 'pathname.c', line 832
static VALUE
path_readable_real_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("readable_real?"), 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 IO.readlines.
358 359 360 361 362 363 364 365 366 367 |
# File 'pathname.c', line 358
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_funcall2(rb_cIO, rb_intern("readlines"), 1+n, args);
}
|
#readlink ⇒ Object
Read symbolic link.
See File.readlink.
559 560 561 562 563 564 565 |
# File 'pathname.c', line 559
static VALUE
path_readlink(VALUE self)
{
VALUE str;
str = rb_funcall(rb_cFile, rb_intern("readlink"), 1, get_strpath(self));
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#realdirpath ⇒ 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.
271 272 273 274 275 276 277 278 |
# File 'pathname.c', line 271
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, rb_intern("realdirpath"), 2, get_strpath(self), basedir);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#realpath ⇒ 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.
255 256 257 258 259 260 261 262 |
# File 'pathname.c', line 255
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, rb_intern("realpath"), 2, get_strpath(self), basedir);
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#relative? ⇒ Boolean
239 240 241 242 243 244 245 |
# File 'lib/pathname.rb', line 239 def relative? path = @path while r = chop_basename(path) path, = r end path == '' 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.
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 |
# File 'lib/pathname.rb', line 484 def relative_path_from(base_directory) dest_directory = self.cleanpath.to_s base_directory = base_directory.cleanpath.to_s dest_prefix = dest_directory dest_names = [] while r = chop_basename(dest_prefix) dest_prefix, basename = r dest_names.unshift basename if basename != '.' end base_prefix = base_directory base_names = [] while r = chop_basename(base_prefix) base_prefix, basename = r base_names.unshift basename if basename != '.' end unless SAME_PATHS[dest_prefix, base_prefix] raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}" end while !dest_names.empty? && !base_names.empty? && SAME_PATHS[dest_names.first, base_names.first] dest_names.shift base_names.shift end if base_names.include? '..' raise ArgumentError, "base_directory has ..: #{base_directory.inspect}" end base_names.fill('..') relpath_names = base_names + dest_names if relpath_names.empty? Pathname.new('.') else Pathname.new(File.join(*relpath_names)) end end |
#rename ⇒ Object
Rename the file.
See File.rename.
572 573 574 575 576 |
# File 'pathname.c', line 572
static VALUE
path_rename(VALUE self, VALUE to)
{
return rb_funcall(rb_cFile, rb_intern("rename"), 2, get_strpath(self), to);
}
|
#rmdir ⇒ Object
Remove the referenced directory.
See Dir.rmdir.
1046 1047 1048 1049 1050 |
# File 'pathname.c', line 1046
static VALUE
path_rmdir(VALUE self)
{
return rb_funcall(rb_cDir, rb_intern("rmdir"), 1, get_strpath(self));
}
|
#rmtree ⇒ Object
Recursively deletes a directory, including all directories beneath it.
See FileUtils.rm_r
563 564 565 566 567 568 569 |
# File 'lib/pathname.rb', line 563 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 |
#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/..
.
209 210 211 |
# File 'lib/pathname.rb', line 209 def root? !!(chop_basename(@path) == nil && /#{SEPARATOR_PAT}/o =~ @path) end |
#setgid? ⇒ Boolean
See FileTest.setgid?.
850 851 852 853 854 |
# File 'pathname.c', line 850
static VALUE
path_setgid_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("setgid?"), 1, get_strpath(self));
}
|
#setuid? ⇒ Boolean
See FileTest.setuid?.
841 842 843 844 845 |
# File 'pathname.c', line 841
static VALUE
path_setuid_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("setuid?"), 1, get_strpath(self));
}
|
#size ⇒ Object
See FileTest.size.
859 860 861 862 863 |
# File 'pathname.c', line 859
static VALUE
path_size(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("size"), 1, get_strpath(self));
}
|
#size? ⇒ Boolean
See FileTest.size?.
868 869 870 871 872 |
# File 'pathname.c', line 868
static VALUE
path_size_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("size?"), 1, get_strpath(self));
}
|
#socket? ⇒ Boolean
See FileTest.socket?.
796 797 798 799 800 |
# File 'pathname.c', line 796
static VALUE
path_socket_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("socket?"), 1, get_strpath(self));
}
|
#split ⇒ Object
Returns the #dirname and the #basename in an Array.
See File.split.
698 699 700 701 702 703 704 705 706 707 708 709 710 |
# File 'pathname.c', line 698
static VALUE
path_split(VALUE self)
{
VALUE str = get_strpath(self);
VALUE ary, dirname, basename;
ary = rb_funcall(rb_cFile, rb_intern("split"), 1, str);
ary = rb_check_array_type(ary);
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.
583 584 585 586 587 |
# File 'pathname.c', line 583
static VALUE
path_stat(VALUE self)
{
return rb_funcall(rb_cFile, rb_intern("stat"), 1, get_strpath(self));
}
|
#sticky? ⇒ Boolean
See FileTest.sticky?.
877 878 879 880 881 |
# File 'pathname.c', line 877
static VALUE
path_sticky_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("sticky?"), 1, get_strpath(self));
}
|
#sub ⇒ Object
Return a pathname which is substituted by String#sub.
path1 = Pathname.new(‘/usr/bin/perl’) path1.sub(‘perl’, ‘ruby’)
#=> #<Pathname:/usr/bin/ruby>
196 197 198 199 200 201 202 203 204 205 206 207 208 |
# File 'pathname.c', line 196
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, rb_intern("sub"), argc, argv, 0, 0);
}
else {
str = rb_funcall2(str, rb_intern("sub"), argc, argv);
}
return rb_class_new_instance(1, &str, rb_obj_class(self));
}
|
#sub_ext ⇒ 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>
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 |
# File 'pathname.c', line 218
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);
OBJ_INFECT(str2, str);
return rb_class_new_instance(1, &str2, rb_obj_class(self));
}
|
#symlink? ⇒ Boolean
See FileTest.symlink?.
886 887 888 889 890 |
# File 'pathname.c', line 886
static VALUE
path_symlink_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("symlink?"), 1, get_strpath(self));
}
|
#sysopen([mode, [perm]]) ⇒ Fixnum
See IO.sysopen.
376 377 378 379 380 381 382 383 384 385 |
# File 'pathname.c', line 376
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_funcall2(rb_cIO, rb_intern("sysopen"), 1+n, args);
}
|
#taint ⇒ Object
Taints this Pathname.
See Object.taint.
73 74 75 76 77 78 79 |
# File 'pathname.c', line 73
static VALUE
path_taint(VALUE self)
{
rb_call_super(0, 0);
rb_obj_taint(get_strpath(self));
return 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.
174 175 176 177 178 |
# File 'pathname.c', line 174
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.
174 175 176 177 178 |
# File 'pathname.c', line 174
static VALUE
path_to_s(VALUE self)
{
return rb_obj_dup(get_strpath(self));
}
|
#truncate ⇒ Object
Truncates the file to length
bytes.
See File.truncate.
617 618 619 620 621 |
# File 'pathname.c', line 617
static VALUE
path_truncate(VALUE self, VALUE length)
{
return rb_funcall(rb_cFile, rb_intern("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.
1101 1102 1103 1104 1105 1106 1107 |
# File 'pathname.c', line 1101
static VALUE
path_unlink(VALUE self)
{
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, rb_intern("ENOTDIR"));
VALUE str = get_strpath(self);
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
}
|
#untaint ⇒ Object
Untaints this Pathname.
See Object.untaint.
89 90 91 92 93 94 95 |
# File 'pathname.c', line 89
static VALUE
path_untaint(VALUE self)
{
rb_call_super(0, 0);
rb_obj_untaint(get_strpath(self));
return self;
}
|
#utime ⇒ Object
Update the access and modification times of the file.
See File.utime.
628 629 630 631 632 |
# File 'pathname.c', line 628
static VALUE
path_utime(VALUE self, VALUE atime, VALUE mtime)
{
return rb_funcall(rb_cFile, rb_intern("utime"), 3, atime, mtime, get_strpath(self));
}
|
#world_readable? ⇒ Boolean
See FileTest.world_readable?.
823 824 825 826 827 |
# File 'pathname.c', line 823
static VALUE
path_world_readable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("world_readable?"), 1, get_strpath(self));
}
|
#world_writable? ⇒ Boolean
See FileTest.world_writable?.
904 905 906 907 908 |
# File 'pathname.c', line 904
static VALUE
path_world_writable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("world_writable?"), 1, get_strpath(self));
}
|
#writable? ⇒ Boolean
See FileTest.writable?.
895 896 897 898 899 |
# File 'pathname.c', line 895
static VALUE
path_writable_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("writable?"), 1, get_strpath(self));
}
|
#writable_real? ⇒ Boolean
See FileTest.writable_real?.
913 914 915 916 917 |
# File 'pathname.c', line 913
static VALUE
path_writable_real_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("writable_real?"), 1, get_strpath(self));
}
|
#zero? ⇒ Boolean
See FileTest.zero?.
922 923 924 925 926 |
# File 'pathname.c', line 922
static VALUE
path_zero_p(VALUE self)
{
return rb_funcall(rb_mFileTest, rb_intern("zero?"), 1, get_strpath(self));
}
|