head

Image

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

IO::Prompt -- Interactive validating terminal prompt


This document describes IO::Prompt version 0.0


=begin code
    use IO::Prompt;

    my $n = ask('How many bananas?',7);
    say "You said $n bananas";
=end code


See example.p6 and lib/IO/Prompt.rakumod for more
examples of usage.


This is a generic module for interactive prompting
from the console. You can install it with zef:


=begin code
    $ zef install IO::Prompt
=end code


The functional interface is exported by default.


item

All user IO is done tru these methods. You can override these
methods to create a testable version of the module.


The default options can be set in the object constructor.


You can override these attributes to create a localization
for this module.


IO::Prompt requires no configuration files or environment variables.


Requires no external modules. Tested and built with Rakudo Perl 6,
revision 38379 built on parrot 1.1.0-devel.


This module is free software; you can redistribute it and/or
modify it under the same terms as Rakudo Perl 6 itself.


BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
NECESSARY SERVICING, REPAIR, OR CORRECTION.


IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.


Prompt

IO::Path::Mode - Augment Raku's IO::Path with a .mode() method to get the file mode


=begin code

use IO::Path::Mode;

my $mode = "some-file".IO.mode;

say $mode.set-user-id ?? 'setuid' !! 'not setuid';

say $mode.user.execute ?? 'executable' !! 'not executable';

say $mode.file-type == IO::Path::Mode::File ?? 'plain file' !! 'something else';

...


=end code


=begin code

use IO::Path::Mode;

for ".".IO.dir -> $f {
    say $f.mode.Str, "   ", $f.Str;
}

=end code


This augments the type L<IO::Path> to provide a C<mode> method that allows
you to get at the file permissions (or mode.)  It follows the POSIX model pf
user, group and other permissions and consequently may not make a meaningful
result on e.g. Windows (although the underlying calls appear to return something
approximating the correct answer.)


If you have a more recent rakudo that provides a C<mode> method, it will replace
that method with one that returns an C<IO::Path::Mode> object rather than an
C<IntStr>, this is a transitional arrangement and will be deprecated in a future
release in favour of a different method name.


It relies on some non-specified functionality in the VM so may probably only work
with Rakudo on MoarVM.


Loading this module will augment L<IO::Path> with a C<mode> method which returns
an L<IO::Path::Mode> object representing the mode of the C<file>. The methods
documented below are those of the L<IO::Path::Mode>.


This is mostly provided as some relief for not having the functionality directly
exposed in Rakudo and as a discussion board for the best way of implementing the
functionality going forward.


This returns the numeric mode of the file as would be returned by C<stat>


This returns the mode of the file as an octal string (e.g 100755 )


Returns the mode as an C<Int>, for the convenience of programmers.
That is to say it can be coerced to an Int.


This returns the mode as an C<Int> it may be useful if a smart match
against a numeric value is required.


This returns the file mode as a string representing the file permissions
as described by POSIX C<ls>.


This returns the file type part of the C<mode> as returned by C<stat>.
An C<enum> is provided for the documented types:


Some systems may document other types than POSIX of course.


returns a L<Bool> to indicate whether the C<setuid> bit is set for the
file, the exact meaning may differ if the C<file-type> is not C<File>.


returns a L<Bool> to indicate whether the C<setguid> is set for the file.
The meaning may differ if the C<file-type> is not C<File>.


This is a C<Bool> that indicates whether the "sticky bit" is
set on the file, traditionally this would indicate that the
text segment of an executable should be kept in memory but it
may be used for different purposes on different platforms and
file types.


This returns the set of permissions that the "owner" of the file
has, represented as an L<Int> with the role C<Permissions> that has
the following methods:


Returns a C<Bool> to indicate the execute permission


Returns a C<Bool> to indicate the write permission




class IO::Path::Mode:ver<0.0.8>:auth<github:jonathanstowe>:api<1.0> {

    my constant S_IFMT  = 0o170000;

    # masks
    my constant S_ISUID = 0o004000; # set user id bit
    my constant S_ISGID = 0o002000; # set group id bit;
    my constant S_ISVTX = 0o001000; # sticky bit

    my constant S_IRWXU = 0o000700; # user perms
    my constant S_IRWXG = 0o000070; # group perms
    my constant S_IRWXO = 0o000007; # other perms


    enum FileType ( Socket          => 0o140000,
                    SymbolicLink    => 0o120000,
                    File            => 0o100000,
                    Block           => 0o060000,
                    Directory       => 0o040000,
                    Character       => 0o020000,
                    FIFO            => 0o010000);

    enum Perms ( Execute => 0o00001, Write => 0o00002, Read => 0o00004);

    role Permissions {
        method execute( --> Bool ) {
            Bool(self.Int +& Execute.Int);
        }
        method write( --> Bool ) {
            Bool(self.Int +& Write.Int);
        }
        method read( --> Bool ) {
            Bool(self.Int +& Read.Int);
        }
        method bits() {
             self.read ?? 'r' !! '-' ,
             self.write ?? 'w' !! '-',
             self.execute ?? 'x' !! '-' ;
        }
    }

    has Int $.mode;
    multi method new(IO::Path:D :$path --> IO::Path::Mode ) {
        self.new(file => $path.Str);
    }
    multi method new(Str:D :$file --> IO::Path::Mode ) {
        my Int $mode = nqp::p6box_i(nqp::lstat(nqp::unbox_s($file), nqp::const::STAT_PLATFORM_MODE));
        self.new(:$mode);
    }

    method gist( --> Str ) {
        $!mode.base(8).Str;
    }

    method Int( --> Int ) {
        $!mode;
    }

    method Numeric( --> Numeric ) {
        self.Int;
    }

    method file-type( --> FileType ) {
        my $ft = $!mode +& S_IFMT;
        FileType($ft);
    }

    method set-user-id( --> Bool ) {
        Bool($!mode +& S_ISUID);
    }

    method set-group-id( --> Bool ) {
        Bool($!mode +& S_ISGID);
    }

    method sticky( --> Bool ) {
        Bool($!mode +& S_ISVTX);
    }

    method user( --> Permissions ) {
        my Int $perms = ($!mode +& S_IRWXU) +> 6;
        $perms but Permissions;
    }
    method group( --> Permissions ) {
        my Int $perms = ($!mode +& S_IRWXG) +> 3;
        $perms but Permissions;
    }
    method other( --> Permissions ) {
        my Int $perms = ($!mode +& S_IRWXO);
        $perms but Permissions;
    }

    method type-char( --> Str ) {
        given self.file-type() {
            when Socket {
                's'
            }
            when SymbolicLink {
                'l'
            }
            when File {
                '-'
            }
            when Block {
                'b'
            }
            when Directory {
                'd'
            }
            when Character {
                'c'
            }
            when FIFO {
                'p'
            }
            default {
                ' '
            }
        }
    }

    method user-bits() {
        my @bits = self.user.bits;
        if self.set-user-id {
            @bits[2] = self.user.execute ?? 's' !! 'S'
        }
        @bits;
    }
    method group-bits() {
        my @bits = self.group.bits;
        if self.set-group-id {
            @bits[2] = self.group.execute ?? 's' !! 'S'
        }
        @bits;
    }
    method other-bits() {
        my @bits = self.other.bits;
        if self.sticky {
            @bits[2] = self.other.execute ?? 't' !! 'T'
        }
        @bits;
    }

    method bits() {
        my @bits = self.type-char;
        @bits.append: self.user-bits.flat;
        @bits.append: self.group-bits.flat;
        @bits.append: self.other-bits.flat;
        @bits.flat;
    }

    method Str( --> Str ) {
        self.bits.join('');
    }
}

# This can theoretically deal with a rakudo that has .mode or doesn't
# but not well tested against the latter case
sub EXPORT()
{
    my $old-method = IO::Path.^lookup('mode');

    if $old-method.defined {
        $old-method.wrap(method () {
            IO::Path::Mode.new(path => self);
        });
    }
    else {
        IO::Path.^add_method('mode', method () {
            IO::Path::Mode.new(path => self);
        });
    }

    %();
}

# vim: expandtab shiftwidth=4 ft=raku


Mode

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

IO::Path::Mode

image i_github_com_jonathanstowe_io_path_mode_workflows_ci_badge_svg not found

Synopsis

Description

Installation

Support

Licence

IO::Path::Mode v0.0.9

Authors

License

Dependencies

Test Dependencies

Provides

Documentation