Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6.d;

use P5opendir:ver<0.0.7>:auth<zef:lizmat>;

class DirHandle:ver<0.0.7>:auth<zef:lizmat> {
    has $.dirhandle;

    method new($path) {
        opendir(my $dirhandle, $path) ?? self.bless(:$dirhandle) !! Nil
    }

    multi method open(DirHandle:U: $path) { DirHandle.new($path) }
    multi method open(DirHandle:D: $path) {
        closedir($!dirhandle);
        opendir($!dirhandle, $path) ?? self !! Nil
    }

    method close(\SELF:) {
        my $result := closedir($!dirhandle);
        SELF = Nil;
        $result
    }

    multi method read(Mu:U) {
        CALLERS::<$_> = readdir(Scalar, $!dirhandle)
    }
    multi method read(:$void!)
        is DEPRECATED('Mu as first positional')
    {
        CALLERS::<$_> = readdir(Scalar, $!dirhandle)
    }
    multi method read() { readdir(Scalar, $!dirhandle) }

    method rewind()         { rewinddir($!dirhandle)       }
    method tell()           { telldir($!dirhandle)         }
    method seek(Int() $pos) { seekdir($!dirhandle,$pos)    }

    method Str() { $!dirhandle.Str }
}



use DirHandle;
with Dirhandle.new(".") -> $d {
    while $d.read -> $entry { something($entry) }
    $d->rewind;
    while $d.read(Mu) { something_else($_) }
    $d.close;
}


This module tries to mimic the behaviour of Perl's C<DirHandle> module
as closely as possible in the Raku Programming Language.


The DirHandle object provides an alternative interface to the C<opendir>,
C<closedir>, C<readdir>, C<telldir>, C<seekdir> and C<rewinddir> functions.


The only objective benefit to using DirHandle is that it avoids namespace
pollution.


Since Raku does not have a concept like void context, one needs to specify
C<Mu> as the only positional parameter with C<read> to mimic the behaviour
of C<DirHandle.read> of Perl in void context.


Please note that due to optimizations in Raku from version C<6.d> onwards,
it is no longer possible to (always) assign to C<$_> in the caller's
scope.  So this either locks your code into C<6.c>, or you will need to
change your code to do explicit assignment with the C<read> method.


The Perl version of C<DirHandle> for some mysterious reason does not
contain methods for performing a C<telldir> or a C<seekdir>.  The Raku
version B<does> contain equivalent methods C<tell> and C<seek>.


Source can be located at: https://github.com/lizmat/DirHandle . Comments
and Pull Requests are welcome.


Re-imagined from Perl as part of the CPAN Butterfly Plan.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


DirHandle

use IO::Dir;
use File::Directory::Tree;
class X::Directory::FileExists is Exception {
    has IO::Path $.path;
    method message() {
        "Cannot create a Directory object. A file already exists at '" ~ $!path
                .Str ~ "'.";
    }
}

class X::Directory::NoHome is Exception {
    has IO::Path $.path;
    method message() {
        "The '~' was used in the path but no \$HOME environment variable exists.";
    }
}

class Directory is IO::Dir {
    has IO::Path $.path is required where dir-check($_);

    sub dir-check(IO::Path:D $path is copy) {
        die (X::Directory::FileExists.new(:$path)) if $path.f.Bool;
        return True;
    }

    method exists() {
        $!path.e;
    }

    method mktree(Int:D $mask = 0o777) {
        mktree($!path, :$mask);
    }

    method rmtree() {
        rmtree($!path);
    }

    method empty-directory() {
        empty-directory($!path);
    }

    method read() {
        my @entries;
        self.open: $.path;
        @entries.push: self.dir(:Str).Slip;
        self.close;
        return @entries;
    }

    submethod BUILD(:$path is copy) {
        if ($path.Str eq '~' || $path.Str.substr(0, 2) eq '~/') {
            die (X::Directory::NoHome.new(:$path)) if !%*ENV<HOME>;
            my $home = %*ENV<HOME>;
            $path = $path.Str.subst('~', $home).IO;
        }
        $!path = $path;
    }

    method new(Str:D $path?) {
        if ($path) {
            self.bless(path => $path.IO);
        } else {
            self.bless(path => $*CWD);
        }
    }

}



Directory - an object representing a directory


=begin code :lang<raku>

use Directory;

# OBJECT CONSTRUCTION
my $dir = Directory.new('/home/user/dir');
my $dir = Directory.new('~');
my $dir = Directory.new();   # current working directory, '.'

# METHODS
my $bool = Directory.new('/some/dir').exists;
my @entries = Directory.new('/some/dir').read;
my $bool = Directory.new('/some/dir').mktree;
my $bool = Directory.new('/some/dir').rmtree;
my $bool = Directory.new('/some/dir').empty-directory;
my $path = Directory.new('/some/dir').path;
Directory.new('/some/dir').open;
Directory.new('/some/dir').open.close;

=end code


A Directory object is a subclass of an IO::Dir object and also wraps
the subroutines found in the File::Tree::Directory distribution with methods.
The module aims to make working with directories very simple.


Creates a new Directory object from the C<$path> supplied or with the path to the
current working directory if no C<$path> is given.  An error is thrown
if a file already exists at the C<$path>. A path beginning with the C<~> character
is replaced with the value of the C<%*ENV<HOME\>> environment variable.


Returns a boolean value of C<True> if the directory exists, C<False> otherwise.


Returns an array of strings for each file and directory in the
Directory object's path.


Returns the IO::Path object for the Directory object.


Opens the Directory object with the C<open> method from C<IO::Dir>


Closes the Directory object with the C<close> method from C<IO::Dir>


A wrapper for the L<File::Directory::Tree>'s mktree command.


A wrapper for the L<File::Directory::Tree>'s rmtree command.


A wrapper for the L<File::Directory::Tree>'s empty-directory command.


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

CONSTRUCTION

new(Str:D $path?)

METHODS

exists

read

path

open

close

mktree($mask = 0o777)

rmtree

empty-directory

AUTHOR

COPYRIGHT AND LICENSE

Directory v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation