2010-07-17 08:50:19 +04:00
|
|
|
#include "ruby.h"
|
2012-01-25 06:32:06 +04:00
|
|
|
#include "ruby/encoding.h"
|
2010-07-17 08:50:19 +04:00
|
|
|
|
|
|
|
static VALUE rb_cPathname;
|
2017-10-21 11:41:59 +03:00
|
|
|
static ID id_ENOTDIR;
|
|
|
|
static ID id_at_path;
|
|
|
|
static ID id_atime;
|
2017-10-21 11:34:49 +03:00
|
|
|
static ID id_base;
|
2017-10-21 11:41:59 +03:00
|
|
|
static ID id_basename;
|
|
|
|
static ID id_binread;
|
|
|
|
static ID id_binwrite;
|
|
|
|
static ID id_birthtime;
|
|
|
|
static ID id_blockdev_p;
|
|
|
|
static ID id_chardev_p;
|
|
|
|
static ID id_chmod;
|
|
|
|
static ID id_chown;
|
|
|
|
static ID id_ctime;
|
|
|
|
static ID id_directory_p;
|
|
|
|
static ID id_dirname;
|
|
|
|
static ID id_empty_p;
|
|
|
|
static ID id_entries;
|
|
|
|
static ID id_executable_p;
|
|
|
|
static ID id_executable_real_p;
|
|
|
|
static ID id_exist_p;
|
|
|
|
static ID id_expand_path;
|
|
|
|
static ID id_extname;
|
|
|
|
static ID id_file_p;
|
|
|
|
static ID id_fnmatch;
|
|
|
|
static ID id_foreach;
|
|
|
|
static ID id_ftype;
|
|
|
|
static ID id_getwd;
|
|
|
|
static ID id_glob;
|
|
|
|
static ID id_grpowned_p;
|
|
|
|
static ID id_lchmod;
|
|
|
|
static ID id_lchown;
|
|
|
|
static ID id_link;
|
|
|
|
static ID id_lstat;
|
2022-04-03 20:03:09 +03:00
|
|
|
static ID id_lutime;
|
2017-10-21 11:41:59 +03:00
|
|
|
static ID id_mkdir;
|
|
|
|
static ID id_mtime;
|
|
|
|
static ID id_open;
|
|
|
|
static ID id_owned_p;
|
|
|
|
static ID id_pipe_p;
|
|
|
|
static ID id_read;
|
|
|
|
static ID id_readable_p;
|
|
|
|
static ID id_readable_real_p;
|
|
|
|
static ID id_readlines;
|
|
|
|
static ID id_readlink;
|
|
|
|
static ID id_realdirpath;
|
|
|
|
static ID id_realpath;
|
|
|
|
static ID id_rename;
|
|
|
|
static ID id_rmdir;
|
|
|
|
static ID id_setgid_p;
|
|
|
|
static ID id_setuid_p;
|
|
|
|
static ID id_size;
|
|
|
|
static ID id_size_p;
|
|
|
|
static ID id_socket_p;
|
|
|
|
static ID id_split;
|
|
|
|
static ID id_stat;
|
|
|
|
static ID id_sticky_p;
|
|
|
|
static ID id_sub;
|
|
|
|
static ID id_symlink;
|
|
|
|
static ID id_symlink_p;
|
|
|
|
static ID id_sysopen;
|
|
|
|
static ID id_to_path;
|
|
|
|
static ID id_truncate;
|
|
|
|
static ID id_unlink;
|
|
|
|
static ID id_utime;
|
|
|
|
static ID id_world_readable_p;
|
|
|
|
static ID id_world_writable_p;
|
|
|
|
static ID id_writable_p;
|
|
|
|
static ID id_writable_real_p;
|
|
|
|
static ID id_write;
|
|
|
|
static ID id_zero_p;
|
2010-07-17 19:03:31 +04:00
|
|
|
|
|
|
|
static VALUE
|
|
|
|
get_strpath(VALUE obj)
|
|
|
|
{
|
2010-07-19 13:35:31 +04:00
|
|
|
VALUE strpath;
|
|
|
|
strpath = rb_ivar_get(obj, id_at_path);
|
2012-05-23 11:13:21 +04:00
|
|
|
if (!RB_TYPE_P(strpath, T_STRING))
|
2010-07-19 13:35:31 +04:00
|
|
|
rb_raise(rb_eTypeError, "unexpected @path");
|
|
|
|
return strpath;
|
2010-07-17 19:03:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_strpath(VALUE obj, VALUE val)
|
|
|
|
{
|
|
|
|
rb_ivar_set(obj, id_at_path, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a Pathname object from the given String (or String-like object).
|
2012-09-12 17:54:08 +04:00
|
|
|
* If +path+ contains a NULL character (<tt>\0</tt>), an ArgumentError is raised.
|
2010-07-17 19:03:31 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_initialize(VALUE self, VALUE arg)
|
|
|
|
{
|
|
|
|
VALUE str;
|
2012-05-23 11:13:21 +04:00
|
|
|
if (RB_TYPE_P(arg, T_STRING)) {
|
2010-07-17 19:03:31 +04:00
|
|
|
str = arg;
|
2010-07-19 13:35:31 +04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
str = rb_check_funcall(arg, id_to_path, 0, NULL);
|
|
|
|
if (str == Qundef)
|
|
|
|
str = arg;
|
|
|
|
StringValue(str);
|
|
|
|
}
|
2010-07-17 19:03:31 +04:00
|
|
|
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);
|
2010-07-17 20:10:19 +04:00
|
|
|
return self;
|
2010-07-17 19:03:31 +04:00
|
|
|
}
|
2010-07-17 08:50:19 +04:00
|
|
|
|
2012-09-12 17:54:08 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.freeze -> obj
|
|
|
|
*
|
|
|
|
* Freezes this Pathname.
|
|
|
|
*
|
|
|
|
* See Object.freeze.
|
|
|
|
*/
|
2010-07-19 13:35:31 +04:00
|
|
|
static VALUE
|
|
|
|
path_freeze(VALUE self)
|
|
|
|
{
|
|
|
|
rb_call_super(0, 0);
|
|
|
|
rb_str_freeze(get_strpath(self));
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
2010-07-28 17:24:55 +04:00
|
|
|
/*
|
|
|
|
* Compare this pathname with +other+. The comparison is string-based.
|
|
|
|
* Be aware that two different paths (<tt>foo.txt</tt> and <tt>./foo.txt</tt>)
|
|
|
|
* can refer to the same file.
|
|
|
|
*/
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2010-07-29 17:29:20 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* 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.
|
2010-07-29 17:29:20 +04:00
|
|
|
*/
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2016-11-04 04:51:18 +03:00
|
|
|
#ifndef ST2FIX
|
|
|
|
#define ST2FIX(h) LONG2FIX((long)(h))
|
|
|
|
#endif
|
|
|
|
|
2010-07-30 16:44:41 +04:00
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
path_hash(VALUE self)
|
|
|
|
{
|
2016-11-04 04:51:18 +03:00
|
|
|
return ST2FIX(rb_str_hash(get_strpath(self)));
|
2010-07-30 16:44:41 +04:00
|
|
|
}
|
|
|
|
|
2010-07-31 04:13:10 +04:00
|
|
|
/*
|
2010-07-31 11:21:42 +04:00
|
|
|
* call-seq:
|
2010-08-08 02:33:51 +04:00
|
|
|
* pathname.to_s -> string
|
|
|
|
* pathname.to_path -> string
|
2010-07-31 11:21:42 +04:00
|
|
|
*
|
2010-07-31 04:13:10 +04:00
|
|
|
* Return the path as a String.
|
2010-07-31 11:21:42 +04:00
|
|
|
*
|
|
|
|
* to_path is implemented so Pathname objects are usable with File.open, etc.
|
2010-07-31 04:13:10 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_to_s(VALUE self)
|
|
|
|
{
|
|
|
|
return rb_obj_dup(get_strpath(self));
|
|
|
|
}
|
|
|
|
|
2010-07-31 18:16:10 +04:00
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
path_inspect(VALUE self)
|
|
|
|
{
|
|
|
|
const char *c = rb_obj_classname(self);
|
|
|
|
VALUE str = get_strpath(self);
|
2013-07-19 09:21:38 +04:00
|
|
|
return rb_sprintf("#<%s:%"PRIsVALUE">", c, str);
|
2010-07-31 18:16:10 +04:00
|
|
|
}
|
|
|
|
|
2010-08-01 04:22:18 +04:00
|
|
|
/*
|
|
|
|
* Return a pathname which is substituted by String#sub.
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* path1 = Pathname.new('/usr/bin/perl')
|
|
|
|
* path1.sub('perl', 'ruby')
|
|
|
|
* #=> #<Pathname:/usr/bin/ruby>
|
2010-08-01 04:22:18 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_sub(int argc, VALUE *argv, VALUE self)
|
|
|
|
{
|
|
|
|
VALUE str = get_strpath(self);
|
|
|
|
|
|
|
|
if (rb_block_given_p()) {
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_block_call(str, id_sub, argc, argv, 0, 0);
|
2010-08-01 04:22:18 +04:00
|
|
|
}
|
|
|
|
else {
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcallv(str, id_sub, argc, argv);
|
2010-08-01 04:22:18 +04:00
|
|
|
}
|
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-01 09:59:49 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Return a pathname with +repl+ added as a suffix to the basename.
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* If self has no extension part, +repl+ is appended.
|
|
|
|
*
|
|
|
|
* Pathname.new('/usr/bin/shutdown').sub_ext('.rb')
|
|
|
|
* #=> #<Pathname:/usr/bin/shutdown.rb>
|
2010-08-01 09:59:49 +04:00
|
|
|
*/
|
|
|
|
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);
|
2012-01-25 06:32:06 +04:00
|
|
|
extlen = RSTRING_LEN(str);
|
|
|
|
ext = ruby_enc_find_extname(p, &extlen, rb_enc_get(str));
|
2010-08-01 09:59:49 +04:00
|
|
|
if (ext == NULL) {
|
|
|
|
ext = p + RSTRING_LEN(str);
|
|
|
|
}
|
|
|
|
else if (extlen <= 1) {
|
|
|
|
ext += extlen;
|
|
|
|
}
|
2012-01-25 06:32:06 +04:00
|
|
|
str2 = rb_str_subseq(str, 0, ext-p);
|
2010-08-01 09:59:49 +04:00
|
|
|
rb_str_append(str2, repl);
|
|
|
|
return rb_class_new_instance(1, &str2, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-05 17:09:53 +04:00
|
|
|
/* Facade for File */
|
|
|
|
|
2010-08-01 15:57:58 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns the real (absolute) pathname for +self+ in the actual
|
|
|
|
* filesystem.
|
|
|
|
*
|
|
|
|
* Does not contain symlinks or useless dots, +..+ and +.+.
|
2010-08-01 15:57:58 +04:00
|
|
|
*
|
|
|
|
* All components of the pathname must exist when this method is
|
|
|
|
* called.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_realpath(int argc, VALUE *argv, VALUE self)
|
|
|
|
{
|
|
|
|
VALUE basedir, str;
|
|
|
|
rb_scan_args(argc, argv, "01", &basedir);
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_realpath, 2, get_strpath(self), basedir);
|
2010-08-01 15:57:58 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-02 00:35:33 +04:00
|
|
|
/*
|
|
|
|
* Returns the real (absolute) pathname of +self+ in the actual filesystem.
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* Does not contain symlinks or useless dots, +..+ and +.+.
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2010-08-02 00:35:33 +04:00
|
|
|
* The last component of the real pathname can be nonexistent.
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_realdirpath(int argc, VALUE *argv, VALUE self)
|
|
|
|
{
|
|
|
|
VALUE basedir, str;
|
|
|
|
rb_scan_args(argc, argv, "01", &basedir);
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_realdirpath, 2, get_strpath(self), basedir);
|
2010-08-02 00:35:33 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-23 18:16:06 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.each_line {|line| ... }
|
|
|
|
* pathname.each_line(sep=$/ [, open_args]) {|line| block } -> nil
|
|
|
|
* pathname.each_line(limit [, open_args]) {|line| block } -> nil
|
|
|
|
* pathname.each_line(sep, limit [, open_args]) {|line| block } -> nil
|
|
|
|
* pathname.each_line(...) -> an_enumerator
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Iterates over each line in the file and yields a String object for each.
|
2010-08-23 18:16:06 +04:00
|
|
|
*/
|
|
|
|
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()) {
|
2021-01-29 07:09:38 +03:00
|
|
|
return rb_block_call_kw(rb_cFile, id_foreach, 1+n, args, 0, 0, RB_PASS_CALLED_KEYWORDS);
|
2010-08-23 18:16:06 +04:00
|
|
|
}
|
|
|
|
else {
|
2021-01-29 07:09:38 +03:00
|
|
|
return rb_funcallv_kw(rb_cFile, id_foreach, 1+n, args, RB_PASS_CALLED_KEYWORDS);
|
2010-08-23 18:16:06 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-24 17:08:00 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.read([length [, offset]]) -> string
|
|
|
|
* pathname.read([length [, offset]], open_args) -> string
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns all data from the file, or the first +N+ bytes if specified.
|
|
|
|
*
|
2018-12-12 08:07:49 +03:00
|
|
|
* See File.read.
|
2010-08-24 17:08:00 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
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]);
|
Make rb_scan_args handle keywords more similar to Ruby methods (#2460)
Cfuncs that use rb_scan_args with the : entry suffer similar keyword
argument separation issues that Ruby methods suffer if the cfuncs
accept optional or variable arguments.
This makes the following changes to : handling.
* Treats as **kw, prompting keyword argument separation warnings
if called with a positional hash.
* Do not look for an option hash if empty keywords are provided.
For backwards compatibility, treat an empty keyword splat as a empty
mandatory positional hash argument, but emit a a warning, as this
behavior will be removed in Ruby 3. The argument number check
needs to be moved lower so it can correctly handle an empty
positional argument being added.
* If the last argument is nil and it is necessary to treat it as an option
hash in order to make sure all arguments are processed, continue to
treat the last argument as the option hash. Emit a warning in this case,
as this behavior will be removed in Ruby 3.
* If splitting the keyword hash into two hashes, issue a warning, as we
will not be splitting hashes in Ruby 3.
* If the keyword argument is required to fill a mandatory positional
argument, continue to do so, but emit a warning as this behavior will
be going away in Ruby 3.
* If keyword arguments are provided and the last argument is not a hash,
that indicates something wrong. This can happen if a cfunc is calling
rb_scan_args multiple times, and providing arguments that were not
passed to it from Ruby. Callers need to switch to the new
rb_scan_args_kw function, which allows passing of whether keywords
were provided.
This commit fixes all warnings caused by the changes above.
It switches some function calls to *_kw versions with appropriate
kw_splat flags. If delegating arguments, RB_PASS_CALLED_KEYWORDS
is used. If creating new arguments, RB_PASS_KEYWORDS is used if
the last argument is a hash to be treated as keywords.
In open_key_args in io.c, use rb_scan_args_kw.
In this case, the arguments provided come from another C
function, not Ruby. The last argument may or may not be a hash,
so we can't set keyword argument mode. However, if it is a
hash, we don't want to warn when treating it as keywords.
In Ruby files, make sure to appropriately use keyword splats
or literal keywords when calling Cfuncs that now issue keyword
argument separation warnings through rb_scan_args. Also, make
sure not to pass nil in place of an option hash.
Work around Kernel#warn warnings due to problems in the Rubygems
override of the method. There is an open pull request to fix
these issues in Rubygems, but part of the Rubygems tests for
their override fail on ruby-head due to rb_scan_args not
recognizing empty keyword splats, which this commit fixes.
Implementation wise, adding rb_scan_args_kw is kind of a pain,
because rb_scan_args takes a variable number of arguments.
In order to not duplicate all the code, the function internals need
to be split into two functions taking a va_list, and to avoid passing
in a ton of arguments, a single struct argument is used to handle
the variables previously local to the function.
2019-09-25 21:18:49 +03:00
|
|
|
return rb_funcallv_kw(rb_cFile, id_read, 1+n, args, RB_PASS_CALLED_KEYWORDS);
|
2010-08-24 17:08:00 +04:00
|
|
|
}
|
|
|
|
|
2010-08-25 17:11:43 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.binread([length [, offset]]) -> string
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns all the bytes from the file, or the first +N+ if specified.
|
|
|
|
*
|
2018-12-12 08:07:49 +03:00
|
|
|
* See File.binread.
|
2010-08-25 17:11:43 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
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]);
|
2018-12-12 08:07:49 +03:00
|
|
|
return rb_funcallv(rb_cFile, id_binread, 1+n, args);
|
2010-08-25 17:11:43 +04:00
|
|
|
}
|
|
|
|
|
2013-04-04 15:12:12 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.write(string, [offset] ) => fixnum
|
|
|
|
* pathname.write(string, [offset], open_args ) => fixnum
|
|
|
|
*
|
|
|
|
* Writes +contents+ to the file.
|
|
|
|
*
|
2018-12-12 08:07:49 +03:00
|
|
|
* See File.write.
|
2013-04-04 15:12:12 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
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]);
|
2019-09-26 01:32:35 +03:00
|
|
|
return rb_funcallv_kw(rb_cFile, id_write, 1+n, args, RB_PASS_CALLED_KEYWORDS);
|
2013-04-04 15:12:12 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.binwrite(string, [offset] ) => fixnum
|
|
|
|
* pathname.binwrite(string, [offset], open_args ) => fixnum
|
|
|
|
*
|
|
|
|
* Writes +contents+ to the file, opening it in binary mode.
|
|
|
|
*
|
2018-12-12 08:07:49 +03:00
|
|
|
* See File.binwrite.
|
2013-04-04 15:12:12 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
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]);
|
2019-09-26 01:32:35 +03:00
|
|
|
return rb_funcallv_kw(rb_cFile, id_binwrite, 1+n, args, RB_PASS_CALLED_KEYWORDS);
|
2013-04-04 15:12:12 +04:00
|
|
|
}
|
|
|
|
|
2010-08-26 16:50:13 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.readlines(sep=$/ [, open_args]) -> array
|
|
|
|
* pathname.readlines(limit [, open_args]) -> array
|
|
|
|
* pathname.readlines(sep, limit [, open_args]) -> array
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns all the lines from the file.
|
|
|
|
*
|
2018-12-12 08:07:49 +03:00
|
|
|
* See File.readlines.
|
2010-08-26 16:50:13 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
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]);
|
2019-09-26 01:32:35 +03:00
|
|
|
return rb_funcallv_kw(rb_cFile, id_readlines, 1+n, args, RB_PASS_CALLED_KEYWORDS);
|
2010-08-26 16:50:13 +04:00
|
|
|
}
|
|
|
|
|
2010-08-27 00:16:25 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.sysopen([mode, [perm]]) -> fixnum
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See IO.sysopen.
|
2010-08-27 00:16:25 +04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
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]);
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcallv(rb_cIO, id_sysopen, 1+n, args);
|
2010-08-27 00:16:25 +04:00
|
|
|
}
|
|
|
|
|
2010-08-04 01:25:43 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
|
|
|
* pathname.atime -> time
|
|
|
|
*
|
|
|
|
* Returns the last access time for the file.
|
|
|
|
*
|
|
|
|
* See File.atime.
|
2010-08-04 01:25:43 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_atime(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_atime, 1, get_strpath(self));
|
2010-08-04 01:25:43 +04:00
|
|
|
}
|
|
|
|
|
2019-02-20 09:54:23 +03:00
|
|
|
#if defined(HAVE_RB_FILE_S_BIRTHTIME)
|
2014-06-28 17:46:02 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.birthtime -> time
|
|
|
|
*
|
|
|
|
* Returns the birth time for the file.
|
2015-01-19 20:57:03 +03:00
|
|
|
* If the platform doesn't have birthtime, raises NotImplementedError.
|
2014-06-28 17:46:02 +04:00
|
|
|
*
|
|
|
|
* See File.birthtime.
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_birthtime(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_birthtime, 1, get_strpath(self));
|
2014-06-28 17:46:02 +04:00
|
|
|
}
|
|
|
|
#else
|
2019-02-20 09:54:23 +03:00
|
|
|
/* check at compilation time for `respond_to?` */
|
2014-06-28 17:46:02 +04:00
|
|
|
# define path_birthtime rb_f_notimplement
|
|
|
|
#endif
|
|
|
|
|
2010-08-05 17:09:53 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
|
|
|
* pathname.ctime -> time
|
|
|
|
*
|
|
|
|
* Returns the last change time, using directory information, not the file itself.
|
|
|
|
*
|
|
|
|
* See File.ctime.
|
2010-08-05 17:09:53 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_ctime(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_ctime, 1, get_strpath(self));
|
2010-08-05 17:09:53 +04:00
|
|
|
}
|
|
|
|
|
2010-08-06 00:53:56 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
|
|
|
* pathname.mtime -> time
|
|
|
|
*
|
|
|
|
* Returns the last modified time of the file.
|
|
|
|
*
|
|
|
|
* See File.mtime.
|
2010-08-06 00:53:56 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_mtime(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_mtime, 1, get_strpath(self));
|
2010-08-06 00:53:56 +04:00
|
|
|
}
|
|
|
|
|
2010-08-06 16:30:28 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
2020-02-15 06:13:09 +03:00
|
|
|
* pathname.chmod(mode_int) -> integer
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* Changes file permissions.
|
|
|
|
*
|
|
|
|
* See File.chmod.
|
2010-08-06 16:30:28 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_chmod(VALUE self, VALUE mode)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_chmod, 2, mode, get_strpath(self));
|
2010-08-06 16:30:28 +04:00
|
|
|
}
|
|
|
|
|
2010-08-06 21:09:31 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
2020-02-15 06:13:09 +03:00
|
|
|
* pathname.lchmod(mode_int) -> integer
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* Same as Pathname.chmod, but does not follow symbolic links.
|
|
|
|
*
|
|
|
|
* See File.lchmod.
|
2010-08-06 21:09:31 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_lchmod(VALUE self, VALUE mode)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_lchmod, 2, mode, get_strpath(self));
|
2010-08-06 21:09:31 +04:00
|
|
|
}
|
|
|
|
|
2010-08-07 03:27:28 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
2020-02-15 06:13:09 +03:00
|
|
|
* pathname.chown(owner_int, group_int) -> integer
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* Change owner and group of the file.
|
|
|
|
*
|
|
|
|
* See File.chown.
|
2010-08-07 03:27:28 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_chown(VALUE self, VALUE owner, VALUE group)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_chown, 3, owner, group, get_strpath(self));
|
2010-08-07 03:27:28 +04:00
|
|
|
}
|
|
|
|
|
2010-08-07 13:21:37 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
2020-02-15 06:13:09 +03:00
|
|
|
* pathname.lchown(owner_int, group_int) -> integer
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* Same as Pathname.chown, but does not follow symbolic links.
|
|
|
|
*
|
|
|
|
* See File.lchown.
|
2010-08-07 13:21:37 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_lchown(VALUE self, VALUE owner, VALUE group)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_lchown, 3, owner, group, get_strpath(self));
|
2010-08-07 13:21:37 +04:00
|
|
|
}
|
|
|
|
|
2010-08-08 02:33:51 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2020-02-24 10:37:33 +03:00
|
|
|
* pathname.fnmatch(pattern, [flags]) -> true or false
|
|
|
|
* pathname.fnmatch?(pattern, [flags]) -> true or false
|
2011-05-15 15:55:52 +04:00
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Return +true+ if the receiver matches the given pattern.
|
|
|
|
*
|
|
|
|
* See File.fnmatch.
|
2010-08-08 02:33:51 +04:00
|
|
|
*/
|
|
|
|
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)
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_fnmatch, 2, pattern, str);
|
2010-08-08 02:33:51 +04:00
|
|
|
else
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_fnmatch, 3, pattern, str, flags);
|
2010-08-08 02:33:51 +04:00
|
|
|
}
|
|
|
|
|
2010-08-08 08:21:26 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* call-seq:
|
|
|
|
* pathname.ftype -> string
|
|
|
|
*
|
|
|
|
* Returns "type" of file ("file", "directory", etc).
|
|
|
|
*
|
|
|
|
* See File.ftype.
|
2010-08-08 08:21:26 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_ftype(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_ftype, 1, get_strpath(self));
|
2010-08-08 08:21:26 +04:00
|
|
|
}
|
|
|
|
|
2010-08-08 14:29:16 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.make_link(old)
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Creates a hard link at _pathname_.
|
|
|
|
*
|
|
|
|
* See File.link.
|
2010-08-08 14:29:16 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_make_link(VALUE self, VALUE old)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_link, 2, old, get_strpath(self));
|
2010-08-08 14:29:16 +04:00
|
|
|
}
|
|
|
|
|
2010-08-09 17:15:49 +04:00
|
|
|
/*
|
2020-02-04 14:54:20 +03:00
|
|
|
* call-seq:
|
|
|
|
* pathname.open()
|
|
|
|
* pathname.open(mode="r" [, opt]) -> file
|
|
|
|
* pathname.open([mode [, perm]] [, opt]) -> file
|
|
|
|
* pathname.open(mode="r" [, opt]) {|file| block } -> obj
|
|
|
|
* pathname.open([mode [, perm]] [, opt]) {|file| block } -> obj
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Opens the file for reading or writing.
|
|
|
|
*
|
|
|
|
* See File.open.
|
2010-08-09 17:15:49 +04:00
|
|
|
*/
|
|
|
|
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()) {
|
2019-09-26 01:32:35 +03:00
|
|
|
return rb_block_call_kw(rb_cFile, id_open, 1+n, args, 0, 0, RB_PASS_CALLED_KEYWORDS);
|
2010-08-09 17:15:49 +04:00
|
|
|
}
|
|
|
|
else {
|
2019-09-26 01:32:35 +03:00
|
|
|
return rb_funcallv_kw(rb_cFile, id_open, 1+n, args, RB_PASS_CALLED_KEYWORDS);
|
2010-08-09 17:15:49 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-10 01:27:20 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Read symbolic link.
|
|
|
|
*
|
|
|
|
* See File.readlink.
|
2010-08-10 01:27:20 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_readlink(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE str;
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_readlink, 1, get_strpath(self));
|
2010-08-10 01:27:20 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-10 15:45:57 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Rename the file.
|
|
|
|
*
|
|
|
|
* See File.rename.
|
2010-08-10 15:45:57 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_rename(VALUE self, VALUE to)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_rename, 2, get_strpath(self), to);
|
2010-08-10 15:45:57 +04:00
|
|
|
}
|
|
|
|
|
2010-08-11 01:19:01 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns a File::Stat object.
|
|
|
|
*
|
|
|
|
* See File.stat.
|
2010-08-11 01:19:01 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_stat(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_stat, 1, get_strpath(self));
|
2010-08-11 01:19:01 +04:00
|
|
|
}
|
|
|
|
|
2010-08-12 16:18:44 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See File.lstat.
|
2010-08-12 16:18:44 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_lstat(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_lstat, 1, get_strpath(self));
|
2010-08-12 16:18:44 +04:00
|
|
|
}
|
|
|
|
|
2010-08-12 18:39:46 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* pathname.make_symlink(old)
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Creates a symbolic link.
|
|
|
|
*
|
|
|
|
* See File.symlink.
|
2010-08-12 18:39:46 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_make_symlink(VALUE self, VALUE old)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_symlink, 2, old, get_strpath(self));
|
2010-08-12 18:39:46 +04:00
|
|
|
}
|
|
|
|
|
2010-08-13 17:49:24 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Truncates the file to +length+ bytes.
|
|
|
|
*
|
|
|
|
* See File.truncate.
|
2010-08-13 17:49:24 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_truncate(VALUE self, VALUE length)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_truncate, 2, get_strpath(self), length);
|
2010-08-13 17:49:24 +04:00
|
|
|
}
|
|
|
|
|
2010-08-14 19:16:19 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Update the access and modification times of the file.
|
|
|
|
*
|
|
|
|
* See File.utime.
|
2010-08-14 19:16:19 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_utime(VALUE self, VALUE atime, VALUE mtime)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_utime, 3, atime, mtime, get_strpath(self));
|
2010-08-14 19:16:19 +04:00
|
|
|
}
|
|
|
|
|
2022-04-03 20:03:09 +03:00
|
|
|
/*
|
|
|
|
* Update the access and modification times of the file.
|
|
|
|
*
|
|
|
|
* Same as Pathname#utime, but does not follow symbolic links.
|
|
|
|
*
|
|
|
|
* See File.lutime.
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_lutime(VALUE self, VALUE atime, VALUE mtime)
|
|
|
|
{
|
|
|
|
return rb_funcall(rb_cFile, id_lutime, 3, atime, mtime, get_strpath(self));
|
|
|
|
}
|
|
|
|
|
2010-08-16 16:40:10 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns the last component of the path.
|
|
|
|
*
|
|
|
|
* See File.basename.
|
2010-08-16 16:40:10 +04:00
|
|
|
*/
|
|
|
|
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)
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_basename, 1, str);
|
2010-08-16 16:40:10 +04:00
|
|
|
else
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_basename, 2, str, fext);
|
2010-08-16 16:40:10 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-17 08:02:32 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns all but the last component of the path.
|
|
|
|
*
|
|
|
|
* See File.dirname.
|
2010-08-17 08:02:32 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_dirname(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE str = get_strpath(self);
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_dirname, 1, str);
|
2010-08-17 08:02:32 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-19 05:06:49 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns the file's extension.
|
|
|
|
*
|
|
|
|
* See File.extname.
|
2010-08-19 05:06:49 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_extname(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE str = get_strpath(self);
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_extname, 1, str);
|
2010-08-19 05:06:49 +04:00
|
|
|
}
|
|
|
|
|
2010-08-20 05:40:51 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns the absolute path for the file.
|
|
|
|
*
|
|
|
|
* See File.expand_path.
|
2010-08-20 05:40:51 +04:00
|
|
|
*/
|
|
|
|
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)
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_expand_path, 1, str);
|
2010-08-20 05:40:51 +04:00
|
|
|
else
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cFile, id_expand_path, 2, str, dname);
|
2010-08-20 05:40:51 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_obj_class(self));
|
|
|
|
}
|
|
|
|
|
2010-08-21 12:37:28 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns the #dirname and the #basename in an Array.
|
|
|
|
*
|
|
|
|
* See File.split.
|
2010-08-21 12:37:28 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_split(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE str = get_strpath(self);
|
|
|
|
VALUE ary, dirname, basename;
|
2017-08-03 10:08:00 +03:00
|
|
|
ary = rb_funcall(rb_cFile, id_split, 1, str);
|
2021-03-27 08:45:10 +03:00
|
|
|
Check_Type(ary, T_ARRAY);
|
2010-08-21 12:37:28 +04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-08-28 03:19:30 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.blockdev?.
|
2010-08-28 03:19:30 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_blockdev_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_blockdev_p, 1, get_strpath(self));
|
2010-08-28 03:19:30 +04:00
|
|
|
}
|
|
|
|
|
2010-08-29 01:34:52 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.chardev?.
|
2010-08-29 01:34:52 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_chardev_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_chardev_p, 1, get_strpath(self));
|
2010-08-29 01:34:52 +04:00
|
|
|
}
|
|
|
|
|
2010-08-30 02:33:09 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.executable?.
|
2010-08-30 02:33:09 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_executable_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_executable_p, 1, get_strpath(self));
|
2010-08-30 02:33:09 +04:00
|
|
|
}
|
|
|
|
|
2010-08-30 16:30:14 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.executable_real?.
|
2010-08-30 16:30:14 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_executable_real_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_executable_real_p, 1, get_strpath(self));
|
2010-08-30 16:30:14 +04:00
|
|
|
}
|
|
|
|
|
2010-08-31 16:11:02 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.exist?.
|
2010-08-31 16:11:02 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_exist_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_exist_p, 1, get_strpath(self));
|
2010-08-31 16:11:02 +04:00
|
|
|
}
|
|
|
|
|
2010-09-01 17:04:10 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.grpowned?.
|
2010-09-01 17:04:10 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_grpowned_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_grpowned_p, 1, get_strpath(self));
|
2010-09-01 17:04:10 +04:00
|
|
|
}
|
|
|
|
|
2010-09-02 01:54:36 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.directory?.
|
2010-09-02 01:54:36 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_directory_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_directory_p, 1, get_strpath(self));
|
2010-09-02 01:54:36 +04:00
|
|
|
}
|
|
|
|
|
2010-09-02 17:11:13 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.file?.
|
2010-09-02 17:11:13 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_file_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_file_p, 1, get_strpath(self));
|
2010-09-02 17:11:13 +04:00
|
|
|
}
|
|
|
|
|
2010-09-03 01:17:31 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.pipe?.
|
2010-09-03 01:17:31 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_pipe_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_pipe_p, 1, get_strpath(self));
|
2010-09-03 01:17:31 +04:00
|
|
|
}
|
|
|
|
|
2010-09-03 18:51:51 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.socket?.
|
2010-09-03 18:51:51 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_socket_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_socket_p, 1, get_strpath(self));
|
2010-09-03 18:51:51 +04:00
|
|
|
}
|
|
|
|
|
2010-09-05 18:03:06 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.owned?.
|
2010-09-05 18:03:06 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_owned_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_owned_p, 1, get_strpath(self));
|
2010-09-05 18:03:06 +04:00
|
|
|
}
|
|
|
|
|
2010-09-06 01:17:54 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.readable?.
|
2010-09-06 01:17:54 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_readable_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_readable_p, 1, get_strpath(self));
|
2010-09-06 01:17:54 +04:00
|
|
|
}
|
|
|
|
|
2010-09-06 18:08:08 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.world_readable?.
|
2010-09-06 18:08:08 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_world_readable_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_world_readable_p, 1, get_strpath(self));
|
2010-09-06 18:08:08 +04:00
|
|
|
}
|
|
|
|
|
2010-09-07 16:04:17 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.readable_real?.
|
2010-09-07 16:04:17 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_readable_real_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_readable_real_p, 1, get_strpath(self));
|
2010-09-07 16:04:17 +04:00
|
|
|
}
|
|
|
|
|
2010-09-08 01:26:33 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.setuid?.
|
2010-09-08 01:26:33 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_setuid_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_setuid_p, 1, get_strpath(self));
|
2010-09-08 01:26:33 +04:00
|
|
|
}
|
|
|
|
|
2010-09-08 15:57:34 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.setgid?.
|
2010-09-08 15:57:34 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_setgid_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_setgid_p, 1, get_strpath(self));
|
2010-09-08 15:57:34 +04:00
|
|
|
}
|
|
|
|
|
2010-09-09 17:43:37 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.size.
|
2010-09-09 17:43:37 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_size(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_size, 1, get_strpath(self));
|
2010-09-09 17:43:37 +04:00
|
|
|
}
|
|
|
|
|
2010-09-10 02:04:22 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.size?.
|
2010-09-10 02:04:22 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_size_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_size_p, 1, get_strpath(self));
|
2010-09-10 02:04:22 +04:00
|
|
|
}
|
|
|
|
|
2010-09-10 18:04:07 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.sticky?.
|
2010-09-10 18:04:07 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_sticky_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_sticky_p, 1, get_strpath(self));
|
2010-09-10 18:04:07 +04:00
|
|
|
}
|
|
|
|
|
2010-09-11 01:54:24 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.symlink?.
|
2010-09-11 01:54:24 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_symlink_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_symlink_p, 1, get_strpath(self));
|
2010-09-11 01:54:24 +04:00
|
|
|
}
|
|
|
|
|
2010-09-12 04:26:19 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.writable?.
|
2010-09-12 04:26:19 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_writable_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_writable_p, 1, get_strpath(self));
|
2010-09-12 04:26:19 +04:00
|
|
|
}
|
|
|
|
|
2010-09-12 14:31:01 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.world_writable?.
|
2010-09-12 14:31:01 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_world_writable_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_world_writable_p, 1, get_strpath(self));
|
2010-09-12 14:31:01 +04:00
|
|
|
}
|
|
|
|
|
2010-09-13 01:46:04 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.writable_real?.
|
2010-09-13 01:46:04 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_writable_real_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_writable_real_p, 1, get_strpath(self));
|
2010-09-13 01:46:04 +04:00
|
|
|
}
|
|
|
|
|
2010-09-13 15:48:58 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* See FileTest.zero?.
|
2010-09-13 15:48:58 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_zero_p(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_zero_p, 1, get_strpath(self));
|
2010-09-13 15:48:58 +04:00
|
|
|
}
|
|
|
|
|
2016-11-05 06:29:08 +03:00
|
|
|
/*
|
|
|
|
* Tests the file is empty.
|
|
|
|
*
|
|
|
|
* See Dir#empty? and FileTest.empty?.
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_empty_p(VALUE self)
|
|
|
|
{
|
|
|
|
|
|
|
|
VALUE path = get_strpath(self);
|
2017-08-03 10:08:00 +03:00
|
|
|
if (RTEST(rb_funcall(rb_mFileTest, id_directory_p, 1, path)))
|
|
|
|
return rb_funcall(rb_cDir, id_empty_p, 1, path);
|
2016-11-05 06:29:08 +03:00
|
|
|
else
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_mFileTest, id_empty_p, 1, path);
|
2016-11-05 06:29:08 +03:00
|
|
|
}
|
|
|
|
|
2010-09-14 00:14:04 +04:00
|
|
|
static VALUE
|
2017-10-21 11:34:49 +03:00
|
|
|
s_glob_i(RB_BLOCK_CALL_FUNC_ARGLIST(elt, klass))
|
2010-09-14 00:14:04 +04:00
|
|
|
{
|
|
|
|
return rb_yield(rb_class_new_instance(1, &elt, klass));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns or yields Pathname objects.
|
|
|
|
*
|
2017-11-07 23:14:46 +03:00
|
|
|
* Pathname.glob("lib/i*.rb")
|
|
|
|
* #=> [#<Pathname:lib/ipaddr.rb>, #<Pathname:lib/irb.rb>]
|
2012-09-12 17:54:08 +04:00
|
|
|
*
|
|
|
|
* See Dir.glob.
|
2010-09-14 00:14:04 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_s_glob(int argc, VALUE *argv, VALUE klass)
|
|
|
|
{
|
2019-07-14 11:39:21 +03:00
|
|
|
VALUE args[3];
|
2010-09-14 00:14:04 +04:00
|
|
|
int n;
|
|
|
|
|
2019-07-14 11:39:21 +03:00
|
|
|
n = rb_scan_args(argc, argv, "12", &args[0], &args[1], &args[2]);
|
2010-09-14 00:14:04 +04:00
|
|
|
if (rb_block_given_p()) {
|
Make rb_scan_args handle keywords more similar to Ruby methods (#2460)
Cfuncs that use rb_scan_args with the : entry suffer similar keyword
argument separation issues that Ruby methods suffer if the cfuncs
accept optional or variable arguments.
This makes the following changes to : handling.
* Treats as **kw, prompting keyword argument separation warnings
if called with a positional hash.
* Do not look for an option hash if empty keywords are provided.
For backwards compatibility, treat an empty keyword splat as a empty
mandatory positional hash argument, but emit a a warning, as this
behavior will be removed in Ruby 3. The argument number check
needs to be moved lower so it can correctly handle an empty
positional argument being added.
* If the last argument is nil and it is necessary to treat it as an option
hash in order to make sure all arguments are processed, continue to
treat the last argument as the option hash. Emit a warning in this case,
as this behavior will be removed in Ruby 3.
* If splitting the keyword hash into two hashes, issue a warning, as we
will not be splitting hashes in Ruby 3.
* If the keyword argument is required to fill a mandatory positional
argument, continue to do so, but emit a warning as this behavior will
be going away in Ruby 3.
* If keyword arguments are provided and the last argument is not a hash,
that indicates something wrong. This can happen if a cfunc is calling
rb_scan_args multiple times, and providing arguments that were not
passed to it from Ruby. Callers need to switch to the new
rb_scan_args_kw function, which allows passing of whether keywords
were provided.
This commit fixes all warnings caused by the changes above.
It switches some function calls to *_kw versions with appropriate
kw_splat flags. If delegating arguments, RB_PASS_CALLED_KEYWORDS
is used. If creating new arguments, RB_PASS_KEYWORDS is used if
the last argument is a hash to be treated as keywords.
In open_key_args in io.c, use rb_scan_args_kw.
In this case, the arguments provided come from another C
function, not Ruby. The last argument may or may not be a hash,
so we can't set keyword argument mode. However, if it is a
hash, we don't want to warn when treating it as keywords.
In Ruby files, make sure to appropriately use keyword splats
or literal keywords when calling Cfuncs that now issue keyword
argument separation warnings through rb_scan_args. Also, make
sure not to pass nil in place of an option hash.
Work around Kernel#warn warnings due to problems in the Rubygems
override of the method. There is an open pull request to fix
these issues in Rubygems, but part of the Rubygems tests for
their override fail on ruby-head due to rb_scan_args not
recognizing empty keyword splats, which this commit fixes.
Implementation wise, adding rb_scan_args_kw is kind of a pain,
because rb_scan_args takes a variable number of arguments.
In order to not duplicate all the code, the function internals need
to be split into two functions taking a va_list, and to avoid passing
in a ton of arguments, a single struct argument is used to handle
the variables previously local to the function.
2019-09-25 21:18:49 +03:00
|
|
|
return rb_block_call_kw(rb_cDir, id_glob, n, args, s_glob_i, klass, RB_PASS_CALLED_KEYWORDS);
|
2010-09-14 00:14:04 +04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
VALUE ary;
|
|
|
|
long i;
|
Make rb_scan_args handle keywords more similar to Ruby methods (#2460)
Cfuncs that use rb_scan_args with the : entry suffer similar keyword
argument separation issues that Ruby methods suffer if the cfuncs
accept optional or variable arguments.
This makes the following changes to : handling.
* Treats as **kw, prompting keyword argument separation warnings
if called with a positional hash.
* Do not look for an option hash if empty keywords are provided.
For backwards compatibility, treat an empty keyword splat as a empty
mandatory positional hash argument, but emit a a warning, as this
behavior will be removed in Ruby 3. The argument number check
needs to be moved lower so it can correctly handle an empty
positional argument being added.
* If the last argument is nil and it is necessary to treat it as an option
hash in order to make sure all arguments are processed, continue to
treat the last argument as the option hash. Emit a warning in this case,
as this behavior will be removed in Ruby 3.
* If splitting the keyword hash into two hashes, issue a warning, as we
will not be splitting hashes in Ruby 3.
* If the keyword argument is required to fill a mandatory positional
argument, continue to do so, but emit a warning as this behavior will
be going away in Ruby 3.
* If keyword arguments are provided and the last argument is not a hash,
that indicates something wrong. This can happen if a cfunc is calling
rb_scan_args multiple times, and providing arguments that were not
passed to it from Ruby. Callers need to switch to the new
rb_scan_args_kw function, which allows passing of whether keywords
were provided.
This commit fixes all warnings caused by the changes above.
It switches some function calls to *_kw versions with appropriate
kw_splat flags. If delegating arguments, RB_PASS_CALLED_KEYWORDS
is used. If creating new arguments, RB_PASS_KEYWORDS is used if
the last argument is a hash to be treated as keywords.
In open_key_args in io.c, use rb_scan_args_kw.
In this case, the arguments provided come from another C
function, not Ruby. The last argument may or may not be a hash,
so we can't set keyword argument mode. However, if it is a
hash, we don't want to warn when treating it as keywords.
In Ruby files, make sure to appropriately use keyword splats
or literal keywords when calling Cfuncs that now issue keyword
argument separation warnings through rb_scan_args. Also, make
sure not to pass nil in place of an option hash.
Work around Kernel#warn warnings due to problems in the Rubygems
override of the method. There is an open pull request to fix
these issues in Rubygems, but part of the Rubygems tests for
their override fail on ruby-head due to rb_scan_args not
recognizing empty keyword splats, which this commit fixes.
Implementation wise, adding rb_scan_args_kw is kind of a pain,
because rb_scan_args takes a variable number of arguments.
In order to not duplicate all the code, the function internals need
to be split into two functions taking a va_list, and to avoid passing
in a ton of arguments, a single struct argument is used to handle
the variables previously local to the function.
2019-09-25 21:18:49 +03:00
|
|
|
ary = rb_funcallv_kw(rb_cDir, id_glob, n, args, RB_PASS_CALLED_KEYWORDS);
|
2010-09-14 00:14:04 +04:00
|
|
|
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
|
|
|
|
for (i = 0; i < RARRAY_LEN(ary); i++) {
|
2013-08-26 09:47:27 +04:00
|
|
|
VALUE elt = RARRAY_AREF(ary, i);
|
2010-09-14 00:14:04 +04:00
|
|
|
elt = rb_class_new_instance(1, &elt, klass);
|
|
|
|
rb_ary_store(ary, i, elt);
|
|
|
|
}
|
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-21 11:34:49 +03:00
|
|
|
static VALUE
|
|
|
|
glob_i(RB_BLOCK_CALL_FUNC_ARGLIST(elt, self))
|
|
|
|
{
|
|
|
|
elt = rb_funcall(self, '+', 1, elt);
|
|
|
|
return rb_yield(elt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns or yields Pathname objects.
|
|
|
|
*
|
|
|
|
* Pathname("ruby-2.4.2").glob("R*.md")
|
|
|
|
* #=> [#<Pathname:ruby-2.4.2/README.md>, #<Pathname:ruby-2.4.2/README.ja.md>]
|
|
|
|
*
|
|
|
|
* See Dir.glob.
|
2017-11-07 23:14:46 +03:00
|
|
|
* This method uses the +base+ keyword argument of Dir.glob.
|
2017-10-21 11:34:49 +03:00
|
|
|
*/
|
|
|
|
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()) {
|
Make rb_scan_args handle keywords more similar to Ruby methods (#2460)
Cfuncs that use rb_scan_args with the : entry suffer similar keyword
argument separation issues that Ruby methods suffer if the cfuncs
accept optional or variable arguments.
This makes the following changes to : handling.
* Treats as **kw, prompting keyword argument separation warnings
if called with a positional hash.
* Do not look for an option hash if empty keywords are provided.
For backwards compatibility, treat an empty keyword splat as a empty
mandatory positional hash argument, but emit a a warning, as this
behavior will be removed in Ruby 3. The argument number check
needs to be moved lower so it can correctly handle an empty
positional argument being added.
* If the last argument is nil and it is necessary to treat it as an option
hash in order to make sure all arguments are processed, continue to
treat the last argument as the option hash. Emit a warning in this case,
as this behavior will be removed in Ruby 3.
* If splitting the keyword hash into two hashes, issue a warning, as we
will not be splitting hashes in Ruby 3.
* If the keyword argument is required to fill a mandatory positional
argument, continue to do so, but emit a warning as this behavior will
be going away in Ruby 3.
* If keyword arguments are provided and the last argument is not a hash,
that indicates something wrong. This can happen if a cfunc is calling
rb_scan_args multiple times, and providing arguments that were not
passed to it from Ruby. Callers need to switch to the new
rb_scan_args_kw function, which allows passing of whether keywords
were provided.
This commit fixes all warnings caused by the changes above.
It switches some function calls to *_kw versions with appropriate
kw_splat flags. If delegating arguments, RB_PASS_CALLED_KEYWORDS
is used. If creating new arguments, RB_PASS_KEYWORDS is used if
the last argument is a hash to be treated as keywords.
In open_key_args in io.c, use rb_scan_args_kw.
In this case, the arguments provided come from another C
function, not Ruby. The last argument may or may not be a hash,
so we can't set keyword argument mode. However, if it is a
hash, we don't want to warn when treating it as keywords.
In Ruby files, make sure to appropriately use keyword splats
or literal keywords when calling Cfuncs that now issue keyword
argument separation warnings through rb_scan_args. Also, make
sure not to pass nil in place of an option hash.
Work around Kernel#warn warnings due to problems in the Rubygems
override of the method. There is an open pull request to fix
these issues in Rubygems, but part of the Rubygems tests for
their override fail on ruby-head due to rb_scan_args not
recognizing empty keyword splats, which this commit fixes.
Implementation wise, adding rb_scan_args_kw is kind of a pain,
because rb_scan_args takes a variable number of arguments.
In order to not duplicate all the code, the function internals need
to be split into two functions taking a va_list, and to avoid passing
in a ton of arguments, a single struct argument is used to handle
the variables previously local to the function.
2019-09-25 21:18:49 +03:00
|
|
|
return rb_block_call_kw(rb_cDir, id_glob, n, args, glob_i, self, RB_PASS_KEYWORDS);
|
2017-10-21 11:34:49 +03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
VALUE ary;
|
|
|
|
long i;
|
Make rb_scan_args handle keywords more similar to Ruby methods (#2460)
Cfuncs that use rb_scan_args with the : entry suffer similar keyword
argument separation issues that Ruby methods suffer if the cfuncs
accept optional or variable arguments.
This makes the following changes to : handling.
* Treats as **kw, prompting keyword argument separation warnings
if called with a positional hash.
* Do not look for an option hash if empty keywords are provided.
For backwards compatibility, treat an empty keyword splat as a empty
mandatory positional hash argument, but emit a a warning, as this
behavior will be removed in Ruby 3. The argument number check
needs to be moved lower so it can correctly handle an empty
positional argument being added.
* If the last argument is nil and it is necessary to treat it as an option
hash in order to make sure all arguments are processed, continue to
treat the last argument as the option hash. Emit a warning in this case,
as this behavior will be removed in Ruby 3.
* If splitting the keyword hash into two hashes, issue a warning, as we
will not be splitting hashes in Ruby 3.
* If the keyword argument is required to fill a mandatory positional
argument, continue to do so, but emit a warning as this behavior will
be going away in Ruby 3.
* If keyword arguments are provided and the last argument is not a hash,
that indicates something wrong. This can happen if a cfunc is calling
rb_scan_args multiple times, and providing arguments that were not
passed to it from Ruby. Callers need to switch to the new
rb_scan_args_kw function, which allows passing of whether keywords
were provided.
This commit fixes all warnings caused by the changes above.
It switches some function calls to *_kw versions with appropriate
kw_splat flags. If delegating arguments, RB_PASS_CALLED_KEYWORDS
is used. If creating new arguments, RB_PASS_KEYWORDS is used if
the last argument is a hash to be treated as keywords.
In open_key_args in io.c, use rb_scan_args_kw.
In this case, the arguments provided come from another C
function, not Ruby. The last argument may or may not be a hash,
so we can't set keyword argument mode. However, if it is a
hash, we don't want to warn when treating it as keywords.
In Ruby files, make sure to appropriately use keyword splats
or literal keywords when calling Cfuncs that now issue keyword
argument separation warnings through rb_scan_args. Also, make
sure not to pass nil in place of an option hash.
Work around Kernel#warn warnings due to problems in the Rubygems
override of the method. There is an open pull request to fix
these issues in Rubygems, but part of the Rubygems tests for
their override fail on ruby-head due to rb_scan_args not
recognizing empty keyword splats, which this commit fixes.
Implementation wise, adding rb_scan_args_kw is kind of a pain,
because rb_scan_args takes a variable number of arguments.
In order to not duplicate all the code, the function internals need
to be split into two functions taking a va_list, and to avoid passing
in a ton of arguments, a single struct argument is used to handle
the variables previously local to the function.
2019-09-25 21:18:49 +03:00
|
|
|
ary = rb_funcallv_kw(rb_cDir, id_glob, n, args, RB_PASS_KEYWORDS);
|
2017-10-21 11:34:49 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-14 15:18:37 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Returns the current working directory as a Pathname.
|
|
|
|
*
|
|
|
|
* Pathname.getwd
|
|
|
|
* #=> #<Pathname:/home/zzak/projects/ruby>
|
|
|
|
*
|
|
|
|
* See Dir.getwd.
|
2010-09-14 15:18:37 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_s_getwd(VALUE klass)
|
|
|
|
{
|
|
|
|
VALUE str;
|
2017-08-03 10:08:00 +03:00
|
|
|
str = rb_funcall(rb_cDir, id_getwd, 0);
|
2010-09-14 15:18:37 +04:00
|
|
|
return rb_class_new_instance(1, &str, klass);
|
|
|
|
}
|
|
|
|
|
2010-09-15 02:23:09 +04:00
|
|
|
/*
|
|
|
|
* Return the entries (files and subdirectories) in the directory, each as a
|
|
|
|
* Pathname object.
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* The results contains just the names in the directory, without any trailing
|
|
|
|
* slashes or recursive look-up.
|
2012-01-09 15:28:00 +04:00
|
|
|
*
|
|
|
|
* 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>]
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* The result may contain the current directory <code>#<Pathname:.></code> and
|
|
|
|
* the parent directory <code>#<Pathname:..></code>.
|
|
|
|
*
|
|
|
|
* If you don't want +.+ and +..+ and
|
|
|
|
* want directories, consider Pathname#children.
|
2010-09-15 02:23:09 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_entries(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE klass, str, ary;
|
|
|
|
long i;
|
|
|
|
klass = rb_obj_class(self);
|
|
|
|
str = get_strpath(self);
|
2017-08-03 10:08:00 +03:00
|
|
|
ary = rb_funcall(rb_cDir, id_entries, 1, str);
|
2010-09-15 02:23:09 +04:00
|
|
|
ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary");
|
|
|
|
for (i = 0; i < RARRAY_LEN(ary); i++) {
|
2013-08-26 09:47:27 +04:00
|
|
|
VALUE elt = RARRAY_AREF(ary, i);
|
2010-09-15 02:23:09 +04:00
|
|
|
elt = rb_class_new_instance(1, &elt, klass);
|
|
|
|
rb_ary_store(ary, i, elt);
|
|
|
|
}
|
|
|
|
return ary;
|
|
|
|
}
|
|
|
|
|
2010-09-15 16:07:43 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Create the referenced directory.
|
|
|
|
*
|
|
|
|
* See Dir.mkdir.
|
2010-09-15 16:07:43 +04:00
|
|
|
*/
|
|
|
|
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)
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cDir, id_mkdir, 1, str);
|
2010-09-15 16:07:43 +04:00
|
|
|
else
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cDir, id_mkdir, 2, str, vmode);
|
2010-09-15 16:07:43 +04:00
|
|
|
}
|
|
|
|
|
2010-09-16 01:08:19 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Remove the referenced directory.
|
|
|
|
*
|
|
|
|
* See Dir.rmdir.
|
2010-09-16 01:08:19 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_rmdir(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cDir, id_rmdir, 1, get_strpath(self));
|
2010-09-16 01:08:19 +04:00
|
|
|
}
|
|
|
|
|
2010-09-16 18:48:20 +04:00
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Opens the referenced directory.
|
|
|
|
*
|
|
|
|
* See Dir.open.
|
2010-09-16 18:48:20 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_opendir(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE args[1];
|
|
|
|
|
|
|
|
args[0] = get_strpath(self);
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_block_call(rb_cDir, id_open, 1, args, 0, 0);
|
2010-09-16 18:48:20 +04:00
|
|
|
}
|
|
|
|
|
2010-09-18 15:10:36 +04:00
|
|
|
static VALUE
|
2013-11-29 11:59:14 +04:00
|
|
|
each_entry_i(RB_BLOCK_CALL_FUNC_ARGLIST(elt, klass))
|
2010-09-18 15:10:36 +04:00
|
|
|
{
|
|
|
|
return rb_yield(rb_class_new_instance(1, &elt, klass));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Iterates over the entries (files and subdirectories) in the directory,
|
|
|
|
* yielding a Pathname object for each entry.
|
2010-09-18 15:10:36 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_each_entry(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE args[1];
|
2021-09-17 22:12:08 +03:00
|
|
|
RETURN_ENUMERATOR(self, 0, 0);
|
2010-09-18 15:10:36 +04:00
|
|
|
|
|
|
|
args[0] = get_strpath(self);
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_block_call(rb_cDir, id_foreach, 1, args, each_entry_i, rb_obj_class(self));
|
2010-09-18 15:10:36 +04:00
|
|
|
}
|
|
|
|
|
2010-09-19 02:49:34 +04:00
|
|
|
static VALUE
|
|
|
|
unlink_body(VALUE str)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cDir, id_unlink, 1, str);
|
2010-09-19 02:49:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
unlink_rescue(VALUE str, VALUE errinfo)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
return rb_funcall(rb_cFile, id_unlink, 1, str);
|
2010-09-19 02:49:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Removes a file or directory, using File.unlink if +self+ is a file, or
|
|
|
|
* Dir.unlink as necessary.
|
2010-09-19 02:49:34 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_unlink(VALUE self)
|
|
|
|
{
|
2017-08-03 10:08:00 +03:00
|
|
|
VALUE eENOTDIR = rb_const_get_at(rb_mErrno, id_ENOTDIR);
|
2010-09-19 02:49:34 +04:00
|
|
|
VALUE str = get_strpath(self);
|
|
|
|
return rb_rescue2(unlink_body, str, unlink_rescue, str, eENOTDIR, (VALUE)0);
|
|
|
|
}
|
|
|
|
|
2010-09-21 19:01:11 +04:00
|
|
|
/*
|
2013-03-08 08:21:43 +04:00
|
|
|
* :call-seq:
|
|
|
|
* Pathname(path) -> pathname
|
|
|
|
*
|
|
|
|
* Creates a new Pathname object from the given string, +path+, and returns
|
|
|
|
* pathname object.
|
|
|
|
*
|
2013-05-19 07:10:21 +04:00
|
|
|
* In order to use this constructor, you must first require the Pathname
|
2013-03-08 08:21:43 +04:00
|
|
|
* standard library extension.
|
|
|
|
*
|
|
|
|
* require 'pathname'
|
|
|
|
* Pathname("/home/zzak")
|
|
|
|
* #=> #<Pathname:/home/zzak>
|
|
|
|
*
|
|
|
|
* See also Pathname::new for more information.
|
2010-09-21 19:01:11 +04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
path_f_pathname(VALUE self, VALUE str)
|
|
|
|
{
|
Make Kernel#{Pathname,BigDecimal,Complex} return argument if given correct type
This is how Kernel#{Array,String,Float,Integer,Hash,Rational} work.
BigDecimal and Complex instances are always frozen, so this should
not cause backwards compatibility issues for those. Pathname
instances are not frozen, so potentially this could cause backwards
compatibility issues by not returning a new object.
Based on a patch from Joshua Ballanco, some minor changes by me.
Fixes [Bug #7522]
2019-08-07 19:01:33 +03:00
|
|
|
if (CLASS_OF(str) == rb_cPathname)
|
|
|
|
return str;
|
2010-09-21 19:01:11 +04:00
|
|
|
return rb_class_new_instance(1, &str, rb_cPathname);
|
|
|
|
}
|
|
|
|
|
2010-07-30 01:13:34 +04:00
|
|
|
/*
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* Pathname represents the name of a file or directory on the filesystem,
|
|
|
|
* but not the file itself.
|
|
|
|
*
|
|
|
|
* The pathname depends on the Operating System: Unix, Windows, etc.
|
|
|
|
* This library works with pathnames of local OS, however non-Unix pathnames
|
|
|
|
* are supported experimentally.
|
2010-07-30 01:13:34 +04:00
|
|
|
*
|
|
|
|
* A Pathname can be relative or absolute. It's not until you try to
|
|
|
|
* reference the file that it even matters whether the file exists or not.
|
|
|
|
*
|
|
|
|
* Pathname is immutable. It has no method for destructive update.
|
|
|
|
*
|
2012-09-12 17:54:08 +04:00
|
|
|
* The goal of this class is to manipulate file path information in a neater
|
2010-07-30 01:13:34 +04:00
|
|
|
* way than standard Ruby provides. The examples below demonstrate the
|
2012-09-12 17:54:08 +04:00
|
|
|
* difference.
|
|
|
|
*
|
|
|
|
* *All* functionality from File, FileTest, and some from Dir and FileUtils is
|
|
|
|
* included, in an unsurprising way. It is essentially a facade for all of
|
|
|
|
* these, and more.
|
2010-07-30 01:13:34 +04:00
|
|
|
*
|
|
|
|
* == Examples
|
|
|
|
*
|
|
|
|
* === Example 1: Using Pathname
|
|
|
|
*
|
|
|
|
* require 'pathname'
|
|
|
|
* pn = Pathname.new("/usr/bin/ruby")
|
|
|
|
* size = pn.size # 27662
|
|
|
|
* isdir = pn.directory? # false
|
|
|
|
* dir = pn.dirname # Pathname:/usr/bin
|
|
|
|
* base = pn.basename # Pathname:ruby
|
|
|
|
* dir, base = pn.split # [Pathname:/usr/bin, Pathname:ruby]
|
|
|
|
* data = pn.read
|
|
|
|
* pn.open { |f| _ }
|
|
|
|
* pn.each_line { |line| _ }
|
|
|
|
*
|
|
|
|
* === Example 2: Using standard Ruby
|
|
|
|
*
|
|
|
|
* pn = "/usr/bin/ruby"
|
|
|
|
* size = File.size(pn) # 27662
|
|
|
|
* isdir = File.directory?(pn) # false
|
|
|
|
* dir = File.dirname(pn) # "/usr/bin"
|
|
|
|
* base = File.basename(pn) # "ruby"
|
|
|
|
* dir, base = File.split(pn) # ["/usr/bin", "ruby"]
|
|
|
|
* data = File.read(pn)
|
|
|
|
* File.open(pn) { |f| _ }
|
|
|
|
* File.foreach(pn) { |line| _ }
|
|
|
|
*
|
|
|
|
* === Example 3: Special features
|
|
|
|
*
|
|
|
|
* p1 = Pathname.new("/usr/lib") # Pathname:/usr/lib
|
|
|
|
* p2 = p1 + "ruby/1.8" # Pathname:/usr/lib/ruby/1.8
|
|
|
|
* p3 = p1.parent # Pathname:/usr
|
|
|
|
* p4 = p2.relative_path_from(p3) # Pathname:lib/ruby/1.8
|
|
|
|
* pwd = Pathname.pwd # Pathname:/home/gavin
|
|
|
|
* pwd.absolute? # true
|
|
|
|
* p5 = Pathname.new "." # Pathname:.
|
|
|
|
* p5 = p5 + "music/../articles" # Pathname:music/../articles
|
|
|
|
* p5.cleanpath # Pathname:articles
|
|
|
|
* p5.realpath # Pathname:/home/gavin/articles
|
|
|
|
* p5.children # [Pathname:/home/gavin/articles/linux, ...]
|
|
|
|
*
|
|
|
|
* == Breakdown of functionality
|
|
|
|
*
|
|
|
|
* === Core methods
|
|
|
|
*
|
|
|
|
* These methods are effectively manipulating a String, because that's
|
2012-09-12 17:54:08 +04:00
|
|
|
* all a path is. None of these access the file system except for
|
|
|
|
* #mountpoint?, #children, #each_child, #realdirpath and #realpath.
|
2010-07-30 01:13:34 +04:00
|
|
|
*
|
|
|
|
* - +
|
|
|
|
* - #join
|
|
|
|
* - #parent
|
|
|
|
* - #root?
|
|
|
|
* - #absolute?
|
|
|
|
* - #relative?
|
|
|
|
* - #relative_path_from
|
|
|
|
* - #each_filename
|
|
|
|
* - #cleanpath
|
|
|
|
* - #realpath
|
|
|
|
* - #realdirpath
|
|
|
|
* - #children
|
|
|
|
* - #each_child
|
|
|
|
* - #mountpoint?
|
|
|
|
*
|
|
|
|
* === File status predicate methods
|
|
|
|
*
|
|
|
|
* These methods are a facade for FileTest:
|
|
|
|
* - #blockdev?
|
|
|
|
* - #chardev?
|
|
|
|
* - #directory?
|
|
|
|
* - #executable?
|
|
|
|
* - #executable_real?
|
|
|
|
* - #exist?
|
|
|
|
* - #file?
|
|
|
|
* - #grpowned?
|
|
|
|
* - #owned?
|
|
|
|
* - #pipe?
|
|
|
|
* - #readable?
|
|
|
|
* - #world_readable?
|
|
|
|
* - #readable_real?
|
|
|
|
* - #setgid?
|
|
|
|
* - #setuid?
|
|
|
|
* - #size
|
|
|
|
* - #size?
|
|
|
|
* - #socket?
|
|
|
|
* - #sticky?
|
|
|
|
* - #symlink?
|
|
|
|
* - #writable?
|
|
|
|
* - #world_writable?
|
|
|
|
* - #writable_real?
|
|
|
|
* - #zero?
|
|
|
|
*
|
|
|
|
* === File property and manipulation methods
|
|
|
|
*
|
|
|
|
* These methods are a facade for File:
|
|
|
|
* - #atime
|
2014-06-28 17:46:02 +04:00
|
|
|
* - #birthtime
|
2010-07-30 01:13:34 +04:00
|
|
|
* - #ctime
|
|
|
|
* - #mtime
|
|
|
|
* - #chmod(mode)
|
|
|
|
* - #lchmod(mode)
|
|
|
|
* - #chown(owner, group)
|
|
|
|
* - #lchown(owner, group)
|
|
|
|
* - #fnmatch(pattern, *args)
|
|
|
|
* - #fnmatch?(pattern, *args)
|
|
|
|
* - #ftype
|
|
|
|
* - #make_link(old)
|
|
|
|
* - #open(*args, &block)
|
|
|
|
* - #readlink
|
|
|
|
* - #rename(to)
|
|
|
|
* - #stat
|
|
|
|
* - #lstat
|
|
|
|
* - #make_symlink(old)
|
|
|
|
* - #truncate(length)
|
|
|
|
* - #utime(atime, mtime)
|
2022-04-03 20:03:09 +03:00
|
|
|
* - #lutime(atime, mtime)
|
2010-07-30 01:13:34 +04:00
|
|
|
* - #basename(*args)
|
|
|
|
* - #dirname
|
|
|
|
* - #extname
|
|
|
|
* - #expand_path(*args)
|
|
|
|
* - #split
|
|
|
|
*
|
|
|
|
* === Directory methods
|
|
|
|
*
|
|
|
|
* These methods are a facade for Dir:
|
|
|
|
* - Pathname.glob(*args)
|
|
|
|
* - Pathname.getwd / Pathname.pwd
|
|
|
|
* - #rmdir
|
|
|
|
* - #entries
|
|
|
|
* - #each_entry(&block)
|
|
|
|
* - #mkdir(*args)
|
|
|
|
* - #opendir(*args)
|
|
|
|
*
|
|
|
|
* === IO
|
|
|
|
*
|
|
|
|
* These methods are a facade for IO:
|
|
|
|
* - #each_line(*args, &block)
|
|
|
|
* - #read(*args)
|
|
|
|
* - #binread(*args)
|
|
|
|
* - #readlines(*args)
|
|
|
|
* - #sysopen(*args)
|
2020-03-02 08:53:18 +03:00
|
|
|
* - #write(*args)
|
|
|
|
* - #binwrite(*args)
|
2010-07-30 01:13:34 +04:00
|
|
|
*
|
|
|
|
* === Utilities
|
|
|
|
*
|
|
|
|
* These methods are a mixture of Find, FileUtils, and others:
|
|
|
|
* - #find(&block)
|
|
|
|
* - #mkpath
|
|
|
|
* - #rmtree
|
|
|
|
* - #unlink / #delete
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* == Method documentation
|
|
|
|
*
|
|
|
|
* As the above section shows, most of the methods in Pathname are facades. The
|
|
|
|
* documentation for these methods generally just says, for instance, "See
|
|
|
|
* FileTest.writable?", as you should be familiar with the original method
|
|
|
|
* anyway, and its documentation (e.g. through +ri+) will contain more
|
|
|
|
* information. In some cases, a brief description will follow.
|
|
|
|
*/
|
2010-07-17 08:50:19 +04:00
|
|
|
void
|
2014-09-30 09:25:32 +04:00
|
|
|
Init_pathname(void)
|
2010-07-17 08:50:19 +04:00
|
|
|
{
|
2020-12-19 18:40:47 +03:00
|
|
|
#ifdef HAVE_RB_EXT_RACTOR_SAFE
|
|
|
|
rb_ext_ractor_safe(true);
|
|
|
|
#endif
|
|
|
|
|
2017-08-03 10:08:00 +03:00
|
|
|
InitVM(pathname);
|
2010-07-17 19:03:31 +04:00
|
|
|
|
2010-07-17 08:50:19 +04:00
|
|
|
rb_cPathname = rb_define_class("Pathname", rb_cObject);
|
2010-07-17 19:03:31 +04:00
|
|
|
rb_define_method(rb_cPathname, "initialize", path_initialize, 1);
|
2010-07-19 13:35:31 +04:00
|
|
|
rb_define_method(rb_cPathname, "freeze", path_freeze, 0);
|
2010-07-28 17:24:55 +04:00
|
|
|
rb_define_method(rb_cPathname, "==", path_eq, 1);
|
|
|
|
rb_define_method(rb_cPathname, "===", path_eq, 1);
|
|
|
|
rb_define_method(rb_cPathname, "eql?", path_eq, 1);
|
2010-07-29 17:29:20 +04:00
|
|
|
rb_define_method(rb_cPathname, "<=>", path_cmp, 1);
|
2010-07-30 16:44:41 +04:00
|
|
|
rb_define_method(rb_cPathname, "hash", path_hash, 0);
|
2010-07-31 04:13:10 +04:00
|
|
|
rb_define_method(rb_cPathname, "to_s", path_to_s, 0);
|
2010-07-31 11:21:42 +04:00
|
|
|
rb_define_method(rb_cPathname, "to_path", path_to_s, 0);
|
2010-07-31 18:16:10 +04:00
|
|
|
rb_define_method(rb_cPathname, "inspect", path_inspect, 0);
|
2010-08-01 04:22:18 +04:00
|
|
|
rb_define_method(rb_cPathname, "sub", path_sub, -1);
|
2010-08-01 09:59:49 +04:00
|
|
|
rb_define_method(rb_cPathname, "sub_ext", path_sub_ext, 1);
|
2010-08-01 15:57:58 +04:00
|
|
|
rb_define_method(rb_cPathname, "realpath", path_realpath, -1);
|
2010-08-02 00:35:33 +04:00
|
|
|
rb_define_method(rb_cPathname, "realdirpath", path_realdirpath, -1);
|
2010-08-23 18:16:06 +04:00
|
|
|
rb_define_method(rb_cPathname, "each_line", path_each_line, -1);
|
2010-08-24 17:08:00 +04:00
|
|
|
rb_define_method(rb_cPathname, "read", path_read, -1);
|
2010-08-25 17:11:43 +04:00
|
|
|
rb_define_method(rb_cPathname, "binread", path_binread, -1);
|
2010-08-26 16:50:13 +04:00
|
|
|
rb_define_method(rb_cPathname, "readlines", path_readlines, -1);
|
2013-04-04 15:12:12 +04:00
|
|
|
rb_define_method(rb_cPathname, "write", path_write, -1);
|
|
|
|
rb_define_method(rb_cPathname, "binwrite", path_binwrite, -1);
|
2010-08-27 00:16:25 +04:00
|
|
|
rb_define_method(rb_cPathname, "sysopen", path_sysopen, -1);
|
2010-08-04 01:25:43 +04:00
|
|
|
rb_define_method(rb_cPathname, "atime", path_atime, 0);
|
2014-06-28 17:46:02 +04:00
|
|
|
rb_define_method(rb_cPathname, "birthtime", path_birthtime, 0);
|
2010-08-05 17:09:53 +04:00
|
|
|
rb_define_method(rb_cPathname, "ctime", path_ctime, 0);
|
2010-08-06 00:53:56 +04:00
|
|
|
rb_define_method(rb_cPathname, "mtime", path_mtime, 0);
|
2010-08-06 16:30:28 +04:00
|
|
|
rb_define_method(rb_cPathname, "chmod", path_chmod, 1);
|
2010-08-06 21:09:31 +04:00
|
|
|
rb_define_method(rb_cPathname, "lchmod", path_lchmod, 1);
|
2010-08-07 04:32:20 +04:00
|
|
|
rb_define_method(rb_cPathname, "chown", path_chown, 2);
|
2010-08-07 13:21:37 +04:00
|
|
|
rb_define_method(rb_cPathname, "lchown", path_lchown, 2);
|
2010-08-08 02:33:51 +04:00
|
|
|
rb_define_method(rb_cPathname, "fnmatch", path_fnmatch, -1);
|
|
|
|
rb_define_method(rb_cPathname, "fnmatch?", path_fnmatch, -1);
|
2010-08-08 08:21:26 +04:00
|
|
|
rb_define_method(rb_cPathname, "ftype", path_ftype, 0);
|
2010-08-08 14:29:16 +04:00
|
|
|
rb_define_method(rb_cPathname, "make_link", path_make_link, 1);
|
2010-08-09 17:15:49 +04:00
|
|
|
rb_define_method(rb_cPathname, "open", path_open, -1);
|
2010-08-10 01:27:20 +04:00
|
|
|
rb_define_method(rb_cPathname, "readlink", path_readlink, 0);
|
2010-08-10 15:45:57 +04:00
|
|
|
rb_define_method(rb_cPathname, "rename", path_rename, 1);
|
2010-08-11 01:19:01 +04:00
|
|
|
rb_define_method(rb_cPathname, "stat", path_stat, 0);
|
2010-08-12 16:18:44 +04:00
|
|
|
rb_define_method(rb_cPathname, "lstat", path_lstat, 0);
|
2010-08-12 18:39:46 +04:00
|
|
|
rb_define_method(rb_cPathname, "make_symlink", path_make_symlink, 1);
|
2010-08-13 17:49:24 +04:00
|
|
|
rb_define_method(rb_cPathname, "truncate", path_truncate, 1);
|
2010-08-14 19:16:19 +04:00
|
|
|
rb_define_method(rb_cPathname, "utime", path_utime, 2);
|
2022-04-03 20:03:09 +03:00
|
|
|
rb_define_method(rb_cPathname, "lutime", path_lutime, 2);
|
2010-08-16 16:40:10 +04:00
|
|
|
rb_define_method(rb_cPathname, "basename", path_basename, -1);
|
2010-08-17 08:02:32 +04:00
|
|
|
rb_define_method(rb_cPathname, "dirname", path_dirname, 0);
|
2010-08-19 05:06:49 +04:00
|
|
|
rb_define_method(rb_cPathname, "extname", path_extname, 0);
|
2010-08-20 05:40:51 +04:00
|
|
|
rb_define_method(rb_cPathname, "expand_path", path_expand_path, -1);
|
2010-08-21 12:37:28 +04:00
|
|
|
rb_define_method(rb_cPathname, "split", path_split, 0);
|
2010-08-28 03:19:30 +04:00
|
|
|
rb_define_method(rb_cPathname, "blockdev?", path_blockdev_p, 0);
|
2010-08-29 01:34:52 +04:00
|
|
|
rb_define_method(rb_cPathname, "chardev?", path_chardev_p, 0);
|
2010-08-30 02:33:09 +04:00
|
|
|
rb_define_method(rb_cPathname, "executable?", path_executable_p, 0);
|
2010-08-30 16:30:14 +04:00
|
|
|
rb_define_method(rb_cPathname, "executable_real?", path_executable_real_p, 0);
|
2010-08-31 16:11:02 +04:00
|
|
|
rb_define_method(rb_cPathname, "exist?", path_exist_p, 0);
|
2010-09-01 17:04:10 +04:00
|
|
|
rb_define_method(rb_cPathname, "grpowned?", path_grpowned_p, 0);
|
2010-09-02 01:54:36 +04:00
|
|
|
rb_define_method(rb_cPathname, "directory?", path_directory_p, 0);
|
2010-09-02 17:11:13 +04:00
|
|
|
rb_define_method(rb_cPathname, "file?", path_file_p, 0);
|
2010-09-03 01:17:31 +04:00
|
|
|
rb_define_method(rb_cPathname, "pipe?", path_pipe_p, 0);
|
2010-09-03 18:51:51 +04:00
|
|
|
rb_define_method(rb_cPathname, "socket?", path_socket_p, 0);
|
2010-09-05 18:03:06 +04:00
|
|
|
rb_define_method(rb_cPathname, "owned?", path_owned_p, 0);
|
2010-09-06 01:17:54 +04:00
|
|
|
rb_define_method(rb_cPathname, "readable?", path_readable_p, 0);
|
2010-09-06 18:08:08 +04:00
|
|
|
rb_define_method(rb_cPathname, "world_readable?", path_world_readable_p, 0);
|
2010-09-07 16:04:17 +04:00
|
|
|
rb_define_method(rb_cPathname, "readable_real?", path_readable_real_p, 0);
|
2010-09-08 01:26:33 +04:00
|
|
|
rb_define_method(rb_cPathname, "setuid?", path_setuid_p, 0);
|
2010-09-08 15:57:34 +04:00
|
|
|
rb_define_method(rb_cPathname, "setgid?", path_setgid_p, 0);
|
2010-09-09 17:43:37 +04:00
|
|
|
rb_define_method(rb_cPathname, "size", path_size, 0);
|
2010-09-10 02:04:22 +04:00
|
|
|
rb_define_method(rb_cPathname, "size?", path_size_p, 0);
|
2010-09-10 18:04:07 +04:00
|
|
|
rb_define_method(rb_cPathname, "sticky?", path_sticky_p, 0);
|
2010-09-11 01:54:24 +04:00
|
|
|
rb_define_method(rb_cPathname, "symlink?", path_symlink_p, 0);
|
2010-09-12 04:26:19 +04:00
|
|
|
rb_define_method(rb_cPathname, "writable?", path_writable_p, 0);
|
2010-09-12 14:31:01 +04:00
|
|
|
rb_define_method(rb_cPathname, "world_writable?", path_world_writable_p, 0);
|
2010-09-13 01:46:04 +04:00
|
|
|
rb_define_method(rb_cPathname, "writable_real?", path_writable_real_p, 0);
|
2010-09-13 15:48:58 +04:00
|
|
|
rb_define_method(rb_cPathname, "zero?", path_zero_p, 0);
|
2016-11-05 06:29:08 +03:00
|
|
|
rb_define_method(rb_cPathname, "empty?", path_empty_p, 0);
|
2010-09-14 00:14:04 +04:00
|
|
|
rb_define_singleton_method(rb_cPathname, "glob", path_s_glob, -1);
|
2010-09-14 15:18:37 +04:00
|
|
|
rb_define_singleton_method(rb_cPathname, "getwd", path_s_getwd, 0);
|
|
|
|
rb_define_singleton_method(rb_cPathname, "pwd", path_s_getwd, 0);
|
2017-10-21 11:34:49 +03:00
|
|
|
rb_define_method(rb_cPathname, "glob", path_glob, -1);
|
2010-09-15 02:23:09 +04:00
|
|
|
rb_define_method(rb_cPathname, "entries", path_entries, 0);
|
2010-09-15 16:07:43 +04:00
|
|
|
rb_define_method(rb_cPathname, "mkdir", path_mkdir, -1);
|
2010-09-16 01:08:19 +04:00
|
|
|
rb_define_method(rb_cPathname, "rmdir", path_rmdir, 0);
|
2010-09-16 18:48:20 +04:00
|
|
|
rb_define_method(rb_cPathname, "opendir", path_opendir, 0);
|
2010-09-18 15:10:36 +04:00
|
|
|
rb_define_method(rb_cPathname, "each_entry", path_each_entry, 0);
|
2010-09-19 02:49:34 +04:00
|
|
|
rb_define_method(rb_cPathname, "unlink", path_unlink, 0);
|
|
|
|
rb_define_method(rb_cPathname, "delete", path_unlink, 0);
|
2010-09-20 06:26:30 +04:00
|
|
|
rb_undef_method(rb_cPathname, "=~");
|
2010-09-21 19:01:11 +04:00
|
|
|
rb_define_global_function("Pathname", path_f_pathname, 1);
|
2010-07-17 08:50:19 +04:00
|
|
|
}
|
2017-08-03 10:08:00 +03:00
|
|
|
|
|
|
|
void
|
|
|
|
InitVM_pathname(void)
|
|
|
|
{
|
|
|
|
#undef rb_intern
|
|
|
|
id_at_path = rb_intern("@path");
|
|
|
|
id_to_path = rb_intern("to_path");
|
|
|
|
id_ENOTDIR = rb_intern("ENOTDIR");
|
|
|
|
id_atime = rb_intern("atime");
|
|
|
|
id_basename = rb_intern("basename");
|
2017-10-21 11:34:49 +03:00
|
|
|
id_base = rb_intern("base");
|
2017-08-03 10:08:00 +03:00
|
|
|
id_binread = rb_intern("binread");
|
|
|
|
id_binwrite = rb_intern("binwrite");
|
|
|
|
id_birthtime = rb_intern("birthtime");
|
|
|
|
id_blockdev_p = rb_intern("blockdev?");
|
|
|
|
id_chardev_p = rb_intern("chardev?");
|
|
|
|
id_chmod = rb_intern("chmod");
|
|
|
|
id_chown = rb_intern("chown");
|
|
|
|
id_ctime = rb_intern("ctime");
|
|
|
|
id_directory_p = rb_intern("directory?");
|
|
|
|
id_dirname = rb_intern("dirname");
|
|
|
|
id_empty_p = rb_intern("empty?");
|
|
|
|
id_entries = rb_intern("entries");
|
|
|
|
id_executable_p = rb_intern("executable?");
|
|
|
|
id_executable_real_p = rb_intern("executable_real?");
|
|
|
|
id_exist_p = rb_intern("exist?");
|
|
|
|
id_expand_path = rb_intern("expand_path");
|
|
|
|
id_extname = rb_intern("extname");
|
|
|
|
id_file_p = rb_intern("file?");
|
|
|
|
id_fnmatch = rb_intern("fnmatch");
|
|
|
|
id_foreach = rb_intern("foreach");
|
|
|
|
id_ftype = rb_intern("ftype");
|
|
|
|
id_getwd = rb_intern("getwd");
|
|
|
|
id_glob = rb_intern("glob");
|
|
|
|
id_grpowned_p = rb_intern("grpowned?");
|
|
|
|
id_lchmod = rb_intern("lchmod");
|
|
|
|
id_lchown = rb_intern("lchown");
|
|
|
|
id_link = rb_intern("link");
|
|
|
|
id_lstat = rb_intern("lstat");
|
2022-04-03 20:03:09 +03:00
|
|
|
id_lutime = rb_intern("lutime");
|
2017-08-03 10:08:00 +03:00
|
|
|
id_mkdir = rb_intern("mkdir");
|
|
|
|
id_mtime = rb_intern("mtime");
|
|
|
|
id_open = rb_intern("open");
|
|
|
|
id_owned_p = rb_intern("owned?");
|
|
|
|
id_pipe_p = rb_intern("pipe?");
|
|
|
|
id_read = rb_intern("read");
|
|
|
|
id_readable_p = rb_intern("readable?");
|
|
|
|
id_readable_real_p = rb_intern("readable_real?");
|
|
|
|
id_readlines = rb_intern("readlines");
|
|
|
|
id_readlink = rb_intern("readlink");
|
|
|
|
id_realdirpath = rb_intern("realdirpath");
|
|
|
|
id_realpath = rb_intern("realpath");
|
|
|
|
id_rename = rb_intern("rename");
|
|
|
|
id_rmdir = rb_intern("rmdir");
|
|
|
|
id_setgid_p = rb_intern("setgid?");
|
|
|
|
id_setuid_p = rb_intern("setuid?");
|
|
|
|
id_size = rb_intern("size");
|
|
|
|
id_size_p = rb_intern("size?");
|
|
|
|
id_socket_p = rb_intern("socket?");
|
|
|
|
id_split = rb_intern("split");
|
|
|
|
id_stat = rb_intern("stat");
|
|
|
|
id_sticky_p = rb_intern("sticky?");
|
|
|
|
id_sub = rb_intern("sub");
|
|
|
|
id_symlink = rb_intern("symlink");
|
|
|
|
id_symlink_p = rb_intern("symlink?");
|
|
|
|
id_sysopen = rb_intern("sysopen");
|
|
|
|
id_truncate = rb_intern("truncate");
|
|
|
|
id_unlink = rb_intern("unlink");
|
|
|
|
id_utime = rb_intern("utime");
|
|
|
|
id_world_readable_p = rb_intern("world_readable?");
|
|
|
|
id_world_writable_p = rb_intern("world_writable?");
|
|
|
|
id_writable_p = rb_intern("writable?");
|
|
|
|
id_writable_real_p = rb_intern("writable_real?");
|
|
|
|
id_write = rb_intern("write");
|
|
|
|
id_zero_p = rb_intern("zero?");
|
|
|
|
}
|