Class: Dir

Inherits:

Object

Object
Dir

show all

Includes:: Enumerable

Defined in:: dir.c

Class Method Summary collapse

.[] ⇒ Object

Equivalent to calling Dir.glob(array,0) and Dir.glob([string,...],0).
.chdir ⇒ Object

Changes the current working directory of the process to the given string.
.chroot(string) ⇒ 0

Changes this process's idea of the file system root.
.delete ⇒ Object

Deletes the named directory.
.entries(dirname) ⇒ Array

Returns an array containing all of the filenames in the given directory.
.foreach(dirname) {|filename| ... } ⇒ nil

Calls the block once for each entry in the named directory, passing the filename of each entry as a parameter to the block.
.getwd ⇒ Object

Returns the path to the current working directory of this process as a string.
.glob ⇒ Object

Returns the filenames found by expanding pattern which is an Array of the patterns or the pattern String, either as an array or as parameters to the block.
.mkdir(string[, integer]) ⇒ 0

Makes a new directory named by string, with permissions specified by the optional parameter anInteger.
.open ⇒ Object

With no block, open is a synonym for Dir::new.
.pwd ⇒ Object

Returns the path to the current working directory of this process as a string.
.rmdir ⇒ Object

Deletes the named directory.
.unlink ⇒ Object

Deletes the named directory.

Instance Method Summary collapse

#close ⇒ nil

Closes the directory stream.
#each {|filename| ... } ⇒ Dir

Calls the block once for each entry in this directory, passing the filename of each entry as a parameter to the block.
#new(string) ⇒ Dir constructor

Returns a new directory object for the named directory.
#inspect ⇒ String

Return a string describing this Dir object.
#path ⇒ String^?

Returns the path parameter passed to dir's constructor.
#pos ⇒ Object

Returns the current position in dir.
#pos(integer) ⇒ Integer

Synonym for Dir#seek, but returns the position parameter.
#read ⇒ String^?

Reads the next entry from dir and returns it as a string.
#rewind ⇒ Dir

Repositions dir to the first entry.
#seek(integer) ⇒ Dir

Seeks to a particular location in dir.
#tell ⇒ Object

Returns the current position in dir.

Methods included from Enumerable

#all?, #any?, #collect, #count, #cycle, #detect, #drop, #drop_while, #each_cons, #each_slice, #each_with_index, #entries, #enum_cons, #enum_slice, #enum_with_index, #find, #find_all, #find_index, #first, #grep, #group_by, #include?, #inject, #map, #max, #max_by, #member?, #min, #min_by, #minmax, #minmax_by, #none?, #one?, #partition, #reduce, #reject, #reverse_each, #select, #sort, #sort_by, #take, #take_while, #to_a, #zip

Constructor Details

#new(string) ⇒ `Dir`

Returns a new directory object for the named directory.

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.new( string ) -> aDir
 *
 *  Returns a new directory object for the named directory.
 */
static VALUE
dir_initialize(dir, dirname)
    VALUE dir, dirname;
{
    struct dir_data *dp;

    SafeStringValue(dirname);
    Data_Get_Struct(dir, struct dir_data, dp);
    if (dp->dir) closedir(dp->dir);
    if (dp->path) free(dp->path);
    dp->dir = NULL;
    dp->path = NULL;
    dp->dir = opendir(RSTRING(dirname)->ptr);
    if (dp->dir == NULL) {
    if (errno == EMFILE || errno == ENFILE) {
        rb_gc();
        dp->dir = opendir(RSTRING(dirname)->ptr);
    }
    if (dp->dir == NULL) {
        rb_sys_fail(RSTRING(dirname)->ptr);
    }
    }
    dp->path = strdup(RSTRING(dirname)->ptr);

    return dir;
}

Class Method Details

.[](array) ⇒ `Array` .[](string[, string ...)) ⇒ `Array`

Equivalent to calling Dir.glob(array,0) and Dir.glob([string,...],0).

Overloads:

.[](array) ⇒ Array
Returns:
- (Array)
.[](string[, string ...)) ⇒ Array
Returns:
- (Array)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir[ array ]                 => array
 *     Dir[ string [, string ...] ] => array
 *
 *  Equivalent to calling
 *  <code>Dir.glob(</code><i>array,</i><code>0)</code> and 
 *  <code>Dir.glob([</code><i>string,...</i><code>],0)</code>.
 *
 */
static VALUE
dir_s_aref(int argc, VALUE *argv, VALUE obj)

.chdir([ string]) ⇒ `0` .chdir([ string]) {|path| ... } ⇒ `Object`

Changes the current working directory of the process to the given string. When called without an argument, changes the directory to the value of the environment variable HOME, or LOGDIR. SystemCallError (probably Errno::ENOENT) if the target directory does not exist.

If a block is given, it is passed the name of the new current directory, and the block is executed with that as the current directory. The original working directory is restored when the block exits. The return value of chdir is the value of the block. chdir blocks can be nested, but in a multi-threaded program an error will be raised if a thread attempts to open a chdir block while another thread has one open.

Dir.chdir("/var/spool/mail")
puts Dir.pwd
Dir.chdir("/tmp") do
  puts Dir.pwd
  Dir.chdir("/usr") do
    puts Dir.pwd
  end
  puts Dir.pwd
end
puts Dir.pwd

produces:

/var/spool/mail
/tmp
/usr
/tmp
/var/spool/mail

Overloads:

.chdir([ string]) ⇒ 0
Returns:
- (0)
.chdir([ string]) {|path| ... } ⇒ Object
Yields:
- (path)
Returns:
- (Object)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.chdir( [ string] ) => 0
 *     Dir.chdir( [ string] ) {| path | block }  => anObject
 *
 *  Changes the current working directory of the process to the given
 *  string. When called without an argument, changes the directory to
 *  the value of the environment variable <code>HOME</code>, or
 *  <code>LOGDIR</code>. <code>SystemCallError</code> (probably
 *  <code>Errno::ENOENT</code>) if the target directory does not exist.
 *
 *  If a block is given, it is passed the name of the new current
 *  directory, and the block is executed with that as the current
 *  directory. The original working directory is restored when the block
 *  exits. The return value of <code>chdir</code> is the value of the
 *  block. <code>chdir</code> blocks can be nested, but in a
 *  multi-threaded program an error will be raised if a thread attempts
 *  to open a <code>chdir</code> block while another thread has one
 *  open.
 *
 *     Dir.chdir("/var/spool/mail")
 *     puts Dir.pwd
 *     Dir.chdir("/tmp") do
 *       puts Dir.pwd
 *       Dir.chdir("/usr") do
 *         puts Dir.pwd
 *       end
 *       puts Dir.pwd
 *     end
 *     puts Dir.pwd
 *
 *  <em>produces:</em>
 *
 *     /var/spool/mail
 *     /tmp
 *     /usr
 *     /tmp
 *     /var/spool/mail
 */
static VALUE
dir_s_chdir(argc, argv, obj)
    int argc;
    VALUE *argv;
    VALUE obj;
{
    VALUE path = Qnil;

    rb_secure(2);
    if (rb_scan_args(argc, argv, "01", &path) == 1) {
    SafeStringValue(path);
    }
    else {
    const char *dist = getenv("HOME");
    if (!dist) {
        dist = getenv("LOGDIR");
        if (!dist) rb_raise(rb_eArgError, "HOME/LOGDIR not set");
    }
    path = rb_str_new2(dist);
    }

    if (chdir_blocking > 0) {
    if (!rb_block_given_p() || rb_thread_current() != chdir_thread)
        rb_warn("conflicting chdir during another chdir block");
    }

    if (rb_block_given_p()) {
    struct chdir_data args;
    char *cwd = my_getcwd();

    args.old_path = rb_tainted_str_new2(cwd); free(cwd);
    args.new_path = path;
    args.done = Qfalse;
    return rb_ensure(chdir_yield, (VALUE)&args, chdir_restore, (VALUE)&args);
    }
    dir_chdir(path);

    return INT2FIX(0);
}

.chroot(string) ⇒ `0`

Changes this process's idea of the file system root. Only a privileged process may make this call. Not available on all platforms. On Unix systems, see chroot(2) for more information.

Returns:

(0)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.chroot( string ) => 0
 *
 *  Changes this process's idea of the file system root. Only a
 *  privileged process may make this call. Not available on all
 *  platforms. On Unix systems, see <code>chroot(2)</code> for more
 *  information.
 */
static VALUE
dir_s_chroot(dir, path)
    VALUE dir, path;
{
#if defined(HAVE_CHROOT) && !defined(__CHECKER__)
    check_dirname(&path);

    if (chroot(RSTRING(path)->ptr) == -1)
    rb_sys_fail(RSTRING(path)->ptr);

    return INT2FIX(0);
#else
    rb_notimplement();
    return Qnil;        /* not reached */
#endif
}

.delete(string) ⇒ `0` .rmdir(string) ⇒ `0` .unlink(string) ⇒ `0`

Deletes the named directory. Raises a subclass of SystemCallError if the directory isn't empty.

Overloads:

.delete(string) ⇒ 0
Returns:
- (0)
.rmdir(string) ⇒ 0
Returns:
- (0)
.unlink(string) ⇒ 0
Returns:
- (0)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.delete( string ) => 0
 *     Dir.rmdir( string ) => 0
 *     Dir.unlink( string ) => 0
 *
 *  Deletes the named directory. Raises a subclass of
 *  <code>SystemCallError</code> if the directory isn't empty.
 */
static VALUE
dir_s_rmdir(obj, dir)
    VALUE obj, dir;
{
    check_dirname(&dir);
    if (rmdir(RSTRING(dir)->ptr) < 0)
    rb_sys_fail(RSTRING(dir)->ptr);

    return INT2FIX(0);
}

.entries(dirname) ⇒ `Array`

Returns an array containing all of the filenames in the given directory. Will raise a SystemCallError if the named directory doesn't exist.

Dir.entries("testdir")   #=> [".", "..", "config.h", "main.rb"]

Returns:

(Array)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.entries( dirname ) => array
 *
 *  Returns an array containing all of the filenames in the given
 *  directory. Will raise a <code>SystemCallError</code> if the named
 *  directory doesn't exist.
 *
 *     Dir.entries("testdir")   #=> [".", "..", "config.h", "main.rb"]
 *
 */
static VALUE
dir_entries(io, dirname)
    VALUE io, dirname;
{
    VALUE dir;

    dir = dir_open_dir(dirname);
    return rb_ensure(rb_Array, dir, dir_close, dir);
}

.foreach(dirname) {|filename| ... } ⇒ `nil`

Calls the block once for each entry in the named directory, passing the filename of each entry as a parameter to the block.

Dir.foreach("testdir") {|x| puts "Got #{x}" }

produces:

Got .
Got ..
Got config.h
Got main.rb

Yields:

(filename)

Returns:

(nil)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.foreach( dirname ) {| filename | block }  => nil
 *
 *  Calls the block once for each entry in the named directory, passing
 *  the filename of each entry as a parameter to the block.
 *
 *     Dir.foreach("testdir") {|x| puts "Got #{x}" }
 *
 *  <em>produces:</em>
 *
 *     Got .
 *     Got ..
 *     Got config.h
 *     Got main.rb
 *
 */
static VALUE
dir_foreach(io, dirname)
    VALUE io, dirname;
{
    VALUE dir;

    RETURN_ENUMERATOR(io, 1, &dirname);
    dir = dir_open_dir(dirname);
    rb_ensure(dir_each, dir, dir_close, dir);
    return Qnil;
}

.getwd ⇒ `String` .pwd ⇒ `String`

Returns the path to the current working directory of this process as a string.

Dir.chdir("/tmp")   #=> 0
Dir.getwd           #=> "/tmp"

Overloads:

.getwd ⇒ String
Returns:
- (String)
.pwd ⇒ String
Returns:
- (String)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.getwd => string
 *     Dir.pwd => string
 *
 *  Returns the path to the current working directory of this process as
 *  a string.
 *
 *     Dir.chdir("/tmp")   #=> 0
 *     Dir.getwd           #=> "/tmp"
 */
static VALUE
dir_s_getwd(dir)
    VALUE dir;
{
    char *path;
    VALUE cwd;

    rb_secure(4);
    path = my_getcwd();
    cwd = rb_tainted_str_new2(path);

    free(path);
    return cwd;
}

.glob(pattern, [flags]) ⇒ `Array` .glob(pattern, [flags]) {|filename| ... } ⇒ `nil`

Returns the filenames found by expanding pattern which is an Array of the patterns or the pattern String, either as an array or as parameters to the block. Note that this pattern is not a regexp (it's closer to a shell glob). See File::fnmatch for the meaning of the flags parameter. Note that case sensitivity depends on your system (so File::FNM_CASEFOLD is ignored)

*: Matches any file. Can be restricted by other values in the glob. * will match all files; c* will match all files beginning with c; *c will match all files ending with c; and c will match all files that have c in them (including at the beginning or end). Equivalent to / .* /x in regexp.
**: Matches directories recursively.
?: Matches any one character. Equivalent to /.{1}/ in regexp.
[set]: Matches any one character in set. Behaves exactly like character sets in Regexp, including set negation ([^a-z]).
{p,q}: Matches either literal p or literal q. Matching literals may be more than one character in length. More than two literals may be specified. Equivalent to pattern alternation in regexp.
<code></code>: Escapes the next metacharacter.

Dir["config.?"]                     #=> ["config.h"]
Dir.glob("config.?")                #=> ["config.h"]
Dir.glob("*.[a-z][a-z]")            #=> ["main.rb"]
Dir.glob("*.[^r]*")                 #=> ["config.h"]
Dir.glob("*.{rb,h}")                #=> ["main.rb", "config.h"]
Dir.glob("*")                       #=> ["config.h", "main.rb"]
Dir.glob("*", File::FNM_DOTMATCH)   #=> [".", "..", "config.h", "main.rb"]

rbfiles = File.join("**", "*.rb")
Dir.glob(rbfiles)                   #=> ["main.rb",
                                         "lib/song.rb",
                                         "lib/song/karaoke.rb"]
libdirs = File.join("**", "lib")
Dir.glob(libdirs)                   #=> ["lib"]

librbfiles = File.join("**", "lib", "**", "*.rb")
Dir.glob(librbfiles)                #=> ["lib/song.rb",
                                         "lib/song/karaoke.rb"]

librbfiles = File.join("**", "lib", "*.rb")
Dir.glob(librbfiles)                #=> ["lib/song.rb"]

Overloads:

.glob(pattern, [flags]) ⇒ Array
Returns:
- (Array)
.glob(pattern, [flags]) {|filename| ... } ⇒ nil
Yields:
- (filename)
Returns:
- (nil)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.glob( pattern, [flags] ) => array
 *     Dir.glob( pattern, [flags] ) {| filename | block }  => nil
 *
 *  Returns the filenames found by expanding <i>pattern</i> which is
 *  an +Array+ of the patterns or the pattern +String+, either as an
 *  <i>array</i> or as parameters to the block. Note that this pattern
 *  is not a regexp (it's closer to a shell glob). See
 *  <code>File::fnmatch</code> for the meaning of the <i>flags</i>
 *  parameter. Note that case sensitivity depends on your system (so
 *  <code>File::FNM_CASEFOLD</code> is ignored)
 *
 *  <code>*</code>::        Matches any file. Can be restricted by
 *                          other values in the glob. <code>*</code>
 *                          will match all files; <code>c*</code> will
 *                          match all files beginning with
 *                          <code>c</code>; <code>*c</code> will match
 *                          all files ending with <code>c</code>; and
 *                          <code>*c*</code> will match all files that
 *                          have <code>c</code> in them (including at
 *                          the beginning or end). Equivalent to
 *                          <code>/ .* /x</code> in regexp.
 *  <code>**</code>::       Matches directories recursively.
 *  <code>?</code>::        Matches any one character. Equivalent to
 *                          <code>/.{1}/</code> in regexp.
 *  <code>[set]</code>::    Matches any one character in +set+.
 *                          Behaves exactly like character sets in
 *                          Regexp, including set negation
 *                          (<code>[^a-z]</code>).
 *  <code>{p,q}</code>::    Matches either literal <code>p</code> or
 *                          literal <code>q</code>. Matching literals
 *                          may be more than one character in length.
 *                          More than two literals may be specified.
 *                          Equivalent to pattern alternation in
 *                          regexp.
 *  <code>\</code>::        Escapes the next metacharacter.
 *
 *     Dir["config.?"]                     #=> ["config.h"]
 *     Dir.glob("config.?")                #=> ["config.h"]
 *     Dir.glob("*.[a-z][a-z]")            #=> ["main.rb"]
 *     Dir.glob("*.[^r]*")                 #=> ["config.h"]
 *     Dir.glob("*.{rb,h}")                #=> ["main.rb", "config.h"]
 *     Dir.glob("*")                       #=> ["config.h", "main.rb"]
 *     Dir.glob("*", File::FNM_DOTMATCH)   #=> [".", "..", "config.h", "main.rb"]
 *
 *     rbfiles = File.join("**", "*.rb")
 *     Dir.glob(rbfiles)                   #=> ["main.rb",
 *                                              "lib/song.rb",
 *                                              "lib/song/karaoke.rb"]
 *     libdirs = File.join("**", "lib")
 *     Dir.glob(libdirs)                   #=> ["lib"]
 *
 *     librbfiles = File.join("**", "lib", "**", "*.rb")
 *     Dir.glob(librbfiles)                #=> ["lib/song.rb",
 *                                              "lib/song/karaoke.rb"]
 *
 *     librbfiles = File.join("**", "lib", "*.rb")
 *     Dir.glob(librbfiles)                #=> ["lib/song.rb"]
 */
static VALUE
dir_s_glob(argc, argv, obj)
    int argc;
    VALUE *argv;
    VALUE obj;
{
    VALUE str, rflags, ary;
    int flags;

    if (rb_scan_args(argc, argv, "11", &str, &rflags) == 2)
    flags = NUM2INT(rflags);
    else
    flags = 0;

    ary = rb_check_array_type(str);
    if (NIL_P(ary)) {
    ary = rb_push_glob(str, flags);
    }
    else {
    volatile VALUE v = ary;
    ary = dir_globs(RARRAY_LEN(v), RARRAY_PTR(v), flags);
    }

    if (rb_block_given_p()) {
    rb_ary_each(ary);
    return Qnil;
    }
    return ary;
}

.mkdir(string[, integer]) ⇒ `0`

Makes a new directory named by string, with permissions specified by the optional parameter anInteger. The permissions may be modified by the value of File::umask, and are ignored on NT. Raises a SystemCallError if the directory cannot be created. See also the discussion of permissions in the class documentation for File.

Returns:

(0)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.mkdir( string [, integer] ) => 0
 *
 *  Makes a new directory named by <i>string</i>, with permissions
 *  specified by the optional parameter <i>anInteger</i>. The
 *  permissions may be modified by the value of
 *  <code>File::umask</code>, and are ignored on NT. Raises a
 *  <code>SystemCallError</code> if the directory cannot be created. See
 *  also the discussion of permissions in the class documentation for
 *  <code>File</code>.
 *
 */
static VALUE
dir_s_mkdir(argc, argv, obj)
    int argc;
    VALUE *argv;
    VALUE obj;
{
    VALUE path, vmode;
    int mode;

    if (rb_scan_args(argc, argv, "11", &path, &vmode) == 2) {
    mode = NUM2INT(vmode);
    }
    else {
    mode = 0777;
    }

    check_dirname(&path);
    if (mkdir(RSTRING(path)->ptr, mode) == -1)
    rb_sys_fail(RSTRING(path)->ptr);

    return INT2FIX(0);
}

.open(string) ⇒ `Dir` .open(string) {|aDir| ... } ⇒ `Object`

With no block, open is a synonym for Dir::new. If a block is present, it is passed aDir as a parameter. The directory is closed at the end of the block, and Dir::open returns the value of the block.

Overloads:

.open(string) ⇒ Dir
Returns:
- (Dir)
.open(string) {|aDir| ... } ⇒ Object
Yields:
- (aDir)
Returns:
- (Object)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.open( string ) => aDir
 *     Dir.open( string ) {| aDir | block } => anObject
 *
 *  With no block, <code>open</code> is a synonym for
 *  <code>Dir::new</code>. If a block is present, it is passed
 *  <i>aDir</i> as a parameter. The directory is closed at the end of
 *  the block, and <code>Dir::open</code> returns the value of the
 *  block.
 */

static VALUE
dir_s_open(klass, dirname)
    VALUE klass, dirname;
{
    struct dir_data *dp;
    VALUE dir = Data_Make_Struct(klass, struct dir_data, 0, free_dir, dp);

    dir_initialize(dir, dirname);
    if (rb_block_given_p()) {
    return rb_ensure(rb_yield, dir, dir_close, dir);
    }

    return dir;
}

.getwd ⇒ `String` .pwd ⇒ `String`

Returns the path to the current working directory of this process as a string.

Dir.chdir("/tmp")   #=> 0
Dir.getwd           #=> "/tmp"

Overloads:

.getwd ⇒ String
Returns:
- (String)
.pwd ⇒ String
Returns:
- (String)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.getwd => string
 *     Dir.pwd => string
 *
 *  Returns the path to the current working directory of this process as
 *  a string.
 *
 *     Dir.chdir("/tmp")   #=> 0
 *     Dir.getwd           #=> "/tmp"
 */
static VALUE
dir_s_getwd(dir)
    VALUE dir;
{
    char *path;
    VALUE cwd;

    rb_secure(4);
    path = my_getcwd();
    cwd = rb_tainted_str_new2(path);

    free(path);
    return cwd;
}

.delete(string) ⇒ `0` .rmdir(string) ⇒ `0` .unlink(string) ⇒ `0`

Deletes the named directory. Raises a subclass of SystemCallError if the directory isn't empty.

Overloads:

.delete(string) ⇒ 0
Returns:
- (0)
.rmdir(string) ⇒ 0
Returns:
- (0)
.unlink(string) ⇒ 0
Returns:
- (0)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.delete( string ) => 0
 *     Dir.rmdir( string ) => 0
 *     Dir.unlink( string ) => 0
 *
 *  Deletes the named directory. Raises a subclass of
 *  <code>SystemCallError</code> if the directory isn't empty.
 */
static VALUE
dir_s_rmdir(obj, dir)
    VALUE obj, dir;
{
    check_dirname(&dir);
    if (rmdir(RSTRING(dir)->ptr) < 0)
    rb_sys_fail(RSTRING(dir)->ptr);

    return INT2FIX(0);
}

.delete(string) ⇒ `0` .rmdir(string) ⇒ `0` .unlink(string) ⇒ `0`

Deletes the named directory. Raises a subclass of SystemCallError if the directory isn't empty.

Overloads:

.delete(string) ⇒ 0
Returns:
- (0)
.rmdir(string) ⇒ 0
Returns:
- (0)
.unlink(string) ⇒ 0
Returns:
- (0)

# File 'dir.c'

/*
 *  call-seq:
 *     Dir.delete( string ) => 0
 *     Dir.rmdir( string ) => 0
 *     Dir.unlink( string ) => 0
 *
 *  Deletes the named directory. Raises a subclass of
 *  <code>SystemCallError</code> if the directory isn't empty.
 */
static VALUE
dir_s_rmdir(obj, dir)
    VALUE obj, dir;
{
    check_dirname(&dir);
    if (rmdir(RSTRING(dir)->ptr) < 0)
    rb_sys_fail(RSTRING(dir)->ptr);

    return INT2FIX(0);
}

Instance Method Details

#close ⇒ `nil`

Closes the directory stream. Any further attempts to access dir will raise an IOError.

d = Dir.new("testdir")
d.close   #=> nil

Returns:

(nil)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.close => nil
 *
 *  Closes the directory stream. Any further attempts to access
 *  <em>dir</em> will raise an <code>IOError</code>.
 *
 *     d = Dir.new("testdir")
 *     d.close   #=> nil
 */
static VALUE
dir_close(dir)
    VALUE dir;
{
    struct dir_data *dirp;

    GetDIR(dir, dirp);
    closedir(dirp->dir);
    dirp->dir = NULL;

    return Qnil;
}

#each {|filename| ... } ⇒ `Dir`

Calls the block once for each entry in this directory, passing the filename of each entry as a parameter to the block.

d = Dir.new("testdir")
d.each  {|x| puts "Got #{x}" }

produces:

Got .
Got ..
Got config.h
Got main.rb

Yields:

(filename)

Returns:

(Dir)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.each { |filename| block }  => dir
 *
 *  Calls the block once for each entry in this directory, passing the
 *  filename of each entry as a parameter to the block.
 *
 *     d = Dir.new("testdir")
 *     d.each  {|x| puts "Got #{x}" }
 *
 *  <em>produces:</em>
 *
 *     Got .
 *     Got ..
 *     Got config.h
 *     Got main.rb
 */
static VALUE
dir_each(dir)
    VALUE dir;
{
    struct dir_data *dirp;
    struct dirent *dp;

    RETURN_ENUMERATOR(dir, 0, 0);
    GetDIR(dir, dirp);
    rewinddir(dirp->dir);
    for (dp = readdir(dirp->dir); dp != NULL; dp = readdir(dirp->dir)) {
    rb_yield(rb_tainted_str_new(dp->d_name, NAMLEN(dp)));
    if (dirp->dir == NULL) dir_closed();
    }
    return dir;
}

#inspect ⇒ `String`

Return a string describing this Dir object.

Returns:

(String)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.inspect => string
 *
 *  Return a string describing this Dir object.
 */
static VALUE
dir_inspect(dir)
    VALUE dir;
{
    struct dir_data *dirp;

    Data_Get_Struct(dir, struct dir_data, dirp);
    if (dirp->path) {
    const char *c = rb_obj_classname(dir);
    int len = strlen(c) + strlen(dirp->path) + 4;
    VALUE s = rb_str_new(0, len);
    snprintf(RSTRING_PTR(s), len+1, "#<%s:%s>", c, dirp->path);
    return s;
    }
    return rb_funcall(dir, rb_intern("to_s"), 0, 0);
}

#path ⇒ `String`^?

Returns the path parameter passed to dir's constructor.

d = Dir.new("..")
d.path   #=> ".."

Returns:

(String, nil)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.path => string or nil
 *
 *  Returns the path parameter passed to <em>dir</em>'s constructor.
 *
 *     d = Dir.new("..")
 *     d.path   #=> ".."
 */
static VALUE
dir_path(dir)
    VALUE dir;
{
    struct dir_data *dirp;

    Data_Get_Struct(dir, struct dir_data, dirp);
    if (!dirp->path) return Qnil;
    return rb_str_new2(dirp->path);
}

#pos ⇒ `Integer` #tell ⇒ `Integer`

Returns the current position in dir. See also Dir#seek.

d = Dir.new("testdir")
d.tell   #=> 0
d.read   #=> "."
d.tell   #=> 12

Overloads:

#pos ⇒ Integer
Returns:
- (Integer)
#tell ⇒ Integer
Returns:
- (Integer)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.pos => integer
 *     dir.tell => integer
 *
 *  Returns the current position in <em>dir</em>. See also
 *  <code>Dir#seek</code>.
 *
 *     d = Dir.new("testdir")
 *     d.tell   #=> 0
 *     d.read   #=> "."
 *     d.tell   #=> 12
 */
static VALUE
dir_tell(dir)
    VALUE dir;
{
#ifdef HAVE_TELLDIR
    struct dir_data *dirp;
    long pos;

    GetDIR(dir, dirp);
    pos = telldir(dirp->dir);
    return rb_int2inum(pos);
#else
    rb_notimplement();
#endif
}

#pos(integer) ⇒ `Integer`

Synonym for Dir#seek, but returns the position parameter.

d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
d.read                   #=> "."
i = d.pos                #=> 12
d.read                   #=> ".."
d.pos = i                #=> 12
d.read                   #=> ".."

Returns:

(Integer)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.pos( integer ) => integer
 *
 *  Synonym for <code>Dir#seek</code>, but returns the position
 *  parameter.
 *
 *     d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
 *     d.read                   #=> "."
 *     i = d.pos                #=> 12
 *     d.read                   #=> ".."
 *     d.pos = i                #=> 12
 *     d.read                   #=> ".."
 */
static VALUE
dir_set_pos(dir, pos)
    VALUE dir, pos;
{
    dir_seek(dir, pos);
    return pos;
}

#read ⇒ `String`^?

Reads the next entry from dir and returns it as a string. Returns nil at the end of the stream.

d = Dir.new("testdir")
d.read   #=> "."
d.read   #=> ".."
d.read   #=> "config.h"

Returns:

(String, nil)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.read => string or nil
 *
 *  Reads the next entry from <em>dir</em> and returns it as a string.
 *  Returns <code>nil</code> at the end of the stream.
 *
 *     d = Dir.new("testdir")
 *     d.read   #=> "."
 *     d.read   #=> ".."
 *     d.read   #=> "config.h"
 */
static VALUE
dir_read(dir)
    VALUE dir;
{
    struct dir_data *dirp;
    struct dirent *dp;

    GetDIR(dir, dirp);
    errno = 0;
    dp = readdir(dirp->dir);
    if (dp) {
    return rb_tainted_str_new(dp->d_name, NAMLEN(dp));
    }
    else if (errno == 0) {  /* end of stream */
    return Qnil;
    }
    else {
    rb_sys_fail(0);
    }
    return Qnil;        /* not reached */
}

#rewind ⇒ `Dir`

Repositions dir to the first entry.

d = Dir.new("testdir")
d.read     #=> "."
d.rewind   #=> #<Dir:0x401b3fb0>
d.read     #=> "."

Returns:

(Dir)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.rewind => dir
 *
 *  Repositions <em>dir</em> to the first entry.
 *
 *     d = Dir.new("testdir")
 *     d.read     #=> "."
 *     d.rewind   #=> #<Dir:0x401b3fb0>
 *     d.read     #=> "."
 */
static VALUE
dir_rewind(dir)
    VALUE dir;
{
    struct dir_data *dirp;

    if (rb_safe_level() >= 4 && !OBJ_TAINTED(dir)) {
    rb_raise(rb_eSecurityError, "Insecure: can't close");
    }
    GetDIR(dir, dirp);
    rewinddir(dirp->dir);
    return dir;
}

#seek(integer) ⇒ `Dir`

Seeks to a particular location in dir. integer must be a value returned by Dir#tell.

d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
d.read                   #=> "."
i = d.tell               #=> 12
d.read                   #=> ".."
d.seek(i)                #=> #<Dir:0x401b3c40>
d.read                   #=> ".."

Returns:

(Dir)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.seek( integer ) => dir
 *
 *  Seeks to a particular location in <em>dir</em>. <i>integer</i>
 *  must be a value returned by <code>Dir#tell</code>.
 *
 *     d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
 *     d.read                   #=> "."
 *     i = d.tell               #=> 12
 *     d.read                   #=> ".."
 *     d.seek(i)                #=> #<Dir:0x401b3c40>
 *     d.read                   #=> ".."
 */
static VALUE
dir_seek(dir, pos)
    VALUE dir, pos;
{
    struct dir_data *dirp;
    off_t p = NUM2OFFT(pos);

    GetDIR(dir, dirp);
#ifdef HAVE_SEEKDIR
    seekdir(dirp->dir, p);
    return dir;
#else
    rb_notimplement();
#endif
}

#pos ⇒ `Integer` #tell ⇒ `Integer`

Returns the current position in dir. See also Dir#seek.

d = Dir.new("testdir")
d.tell   #=> 0
d.read   #=> "."
d.tell   #=> 12

Overloads:

#pos ⇒ Integer
Returns:
- (Integer)
#tell ⇒ Integer
Returns:
- (Integer)

# File 'dir.c'

/*
 *  call-seq:
 *     dir.pos => integer
 *     dir.tell => integer
 *
 *  Returns the current position in <em>dir</em>. See also
 *  <code>Dir#seek</code>.
 *
 *     d = Dir.new("testdir")
 *     d.tell   #=> 0
 *     d.read   #=> "."
 *     d.tell   #=> 12
 */
static VALUE
dir_tell(dir)
    VALUE dir;
{
#ifdef HAVE_TELLDIR
    struct dir_data *dirp;
    long pos;

    GetDIR(dir, dirp);
    pos = telldir(dirp->dir);
    return rb_int2inum(pos);
#else
    rb_notimplement();
#endif
}

Class: Dir

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Enumerable

Constructor Details

#new(string) ⇒ Dir

Class Method Details

.[](array) ⇒ Array .[](string[, string ...)) ⇒ Array

.chdir([ string]) ⇒ 0 .chdir([ string]) {|path| ... } ⇒ Object

.chroot(string) ⇒ 0

.delete(string) ⇒ 0 .rmdir(string) ⇒ 0 .unlink(string) ⇒ 0

.entries(dirname) ⇒ Array

.foreach(dirname) {|filename| ... } ⇒ nil

.getwd ⇒ String .pwd ⇒ String

.glob(pattern, [flags]) ⇒ Array .glob(pattern, [flags]) {|filename| ... } ⇒ nil

.mkdir(string[, integer]) ⇒ 0

.open(string) ⇒ Dir .open(string) {|aDir| ... } ⇒ Object

.getwd ⇒ String .pwd ⇒ String

.delete(string) ⇒ 0 .rmdir(string) ⇒ 0 .unlink(string) ⇒ 0

.delete(string) ⇒ 0 .rmdir(string) ⇒ 0 .unlink(string) ⇒ 0

Instance Method Details

#close ⇒ nil

#each {|filename| ... } ⇒ Dir

#inspect ⇒ String

#path ⇒ String?

#pos ⇒ Integer #tell ⇒ Integer

#pos(integer) ⇒ Integer

#read ⇒ String?

#rewind ⇒ Dir

#seek(integer) ⇒ Dir

#pos ⇒ Integer #tell ⇒ Integer

#new(string) ⇒ `Dir`

.[](array) ⇒ `Array` .[](string[, string ...)) ⇒ `Array`

.chdir([ string]) ⇒ `0` .chdir([ string]) {|path| ... } ⇒ `Object`

.chroot(string) ⇒ `0`

.delete(string) ⇒ `0` .rmdir(string) ⇒ `0` .unlink(string) ⇒ `0`

.entries(dirname) ⇒ `Array`

.foreach(dirname) {|filename| ... } ⇒ `nil`

.getwd ⇒ `String` .pwd ⇒ `String`

.glob(pattern, [flags]) ⇒ `Array` .glob(pattern, [flags]) {|filename| ... } ⇒ `nil`

.mkdir(string[, integer]) ⇒ `0`

.open(string) ⇒ `Dir` .open(string) {|aDir| ... } ⇒ `Object`

.getwd ⇒ `String` .pwd ⇒ `String`

.delete(string) ⇒ `0` .rmdir(string) ⇒ `0` .unlink(string) ⇒ `0`

.delete(string) ⇒ `0` .rmdir(string) ⇒ `0` .unlink(string) ⇒ `0`

#close ⇒ `nil`

#each {|filename| ... } ⇒ `Dir`

#inspect ⇒ `String`

#path ⇒ `String`^?

#pos ⇒ `Integer` #tell ⇒ `Integer`

#pos(integer) ⇒ `Integer`

#read ⇒ `String`^?

#rewind ⇒ `Dir`

#seek(integer) ⇒ `Dir`

#pos ⇒ `Integer` #tell ⇒ `Integer`