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

Because User::Language is designed to be, in effect, a core Intl module, it is allowed
only *one* dependency: C<Intl::LanguageTag>. This means that many operations that would
be very simple elsewhere by, e.g. consulting Intl::CLDR must be 100% self-contained here.


Due to the added complexity of handling potentially complicated lookups, it is
recommended that highly specialized look ups (e.g. major distributions of operating
systems) be farmed out into specialized modules C<Intl::UserLanguage::OS-Name>.
At the present moment, these are called individually by subs, but as that necessitates
some overhead for each one, a different solution will be devised later that will
load on demand or integrate the calls at build/compile time.



my package UserLanguage {
    my @languages;        #= The user's preferred languages
    my @languages-backup; #= The 'backup' when overriding, effectively a temp var
    my @fallback;         #= The fallback, in case languages could not be determined (rare)
}

# Because we allow the positional arguments,
# the use of the EXPORT sub is obligatory.

#| Exports the User::Language routines into the current scope
sub EXPORT (
        +@fallback-languages #= The language tag(s) to use as the fallback if language detection fails
) {
    use Intl::LanguageTag:auth<zef:guifa>:ver<0.12+>;
    use User::Language::Linux;
    use User::Language::Mac;
    use User::Language::Windows;

    # There are only three variables that need to be persistent
    my LanguageTag() @languages;        #= The user's preferred languages
    my               @languages-backup; #= The 'backup' when overriding, effectively a temp var
    my               @fallback;         #= The fallback, in case languages could not be determined (rare)

    # The fallback can either be specified in the 'use' statement, or defaults
    # to English (because linguistic hegemony and all -- but don't think I haven't
    # been tempted to set it to something like Guarani just for funsies).
    @fallback = @fallback-languages
        ?? @fallback-languages
        !! 'en';


    #| Obtains the user’s preferred language(s) in LanguageTag format.
    sub user-languages(+@default) {
        return @languages if @languages;
        say "detecting";
        @languages =
            do given $*DISTRO  {
                when .is-win   {  windows     }
                when /macos/   {    mac       }
                when /linux/   {   linux      }
                CATCH          {  default {}  }  # By doing nothing, we fall through to…
            } //               ( @default        # Return the fallback,
                                 || @fallback ); #   or defined at 'use'
    }

  #| Obtains the user’s preferred language in LanguageTag format.
  sub user-language($default = Empty) {
      user-languages($default).head;
  }

  Map.new:
          '&user-language'  => &user-language,
          '&user-languages' => &user-languages,
}


my package EXPORT::override {
    &OUR::override-user-languages =
        sub override-user-languages(+@languages is copy) {
            use Intl::LanguageTag;
            @UserLanguage::languages-backup = @UserLanguage::languages;
            @UserLanguage::languages        = @languages
        };

    &OUR::clear-user-language-override =
        sub clear-user-language-override {
            @UserLanguage::languages = @UserLanguage::languages-backup;
        }
}


Language

use v6.*;

our $gr_name    is export(:FIELDS);
our $gr_passwd  is export(:FIELDS);
our $gr_gid     is export(:FIELDS);
our @gr_members is export(:FIELDS);

class User::grent:ver<0.0.4>:auth<zef:lizmat> {
    has Str $.name;
    has Str $.passwd;
    has Int $.gid;
    has @.members;
}

sub populate(@fields) {
    if @fields {
        User::grent.new(
          name    => ($gr_name    = @fields[0]),
          passwd  => ($gr_passwd  = @fields[1]),
          gid     => ($gr_gid     = @fields[2]),
          members => (@gr_members = @fields[3].split(" ")),
        )
    }
    else {
          $gr_name    = Str;
          $gr_passwd  = Str;
          $gr_gid     = Int;
          @gr_members = ();
          Nil
    }
}

my sub getgrnam(Str() $name) is export(:DEFAULT:FIELDS) {
    use P5getgrnam:ver<0.0.9>:auth<zef:lizmat>;
    populate(getgrnam($name))
}

my sub getgrgid(Int() $gid) is export(:DEFAULT:FIELDS) {
    use P5getgrnam:ver<0.0.9>:auth<zef:lizmat>;
    populate(getgrgid($gid))
}

my sub getgrent() is export(:DEFAULT:FIELDS) {
    use P5getgrnam:ver<0.0.9>:auth<zef:lizmat>;
    populate(getgrent)
}

my proto sub getgr(|) is export(:DEFAULT:FIELDS) {*}
my multi sub getgr(Int:D $gid) is export(:DEFAULT:FIELDS) { getgrgid($gid) }
my multi sub getgr(Str:D $nam) is export(:DEFAULT:FIELDS) { getgrnam($nam) }

my constant &setgrent is export(:DEFAULT:FIELDS) = do {
    use P5getgrnam:ver<0.0.9>:auth<zef:lizmat>;
    &setgrent
}
my constant &endgrent is export(:DEFAULT:FIELDS) = do {
    use P5getgrnam:ver<0.0.9>:auth<zef:lizmat>;
    &endgrent
}



use User::grent;
$gr = getgrgid(0) or die "No group zero";
if $gr.name eq 'wheel' && $gr.members > 1 {
    print "gid zero name wheel, with other members";
} 


use User::grent qw(:FIELDS);
getgrgid(0) or die "No group zero";
if $gr_name eq 'wheel' && @gr_members > 1 {
    print "gid zero name wheel, with other members";
} 


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


This module's default exports C<getgrent>, C<getgrgid>, and C<getgrnam>
functions, replacing them with versions that return C<User::grent> objects.
This object has methods that return the similarly named structure field name
from the C's passwd structure from grp.h; namely name, passwd, gid, and members
(not mem). The first three return scalars, the last an array.


You may also import all the structure fields directly into your namespace as
regular variables using the :FIELDS import tag. (Note that this still exports
the functions.) Access these fields as variables named with a preceding gr_.
Thus, C<$group_obj.gid> corresponds to C<$gr_gid> if you import the fields.


The C<getgr> function is a simple front-end that forwards a numeric argumenti
to C<getgrgid> and the rest to C<getgrnam>.


This module depends on the availability of POSIX semantics.  This is
generally not available on Windows, so this module will probably not work
on Windows.


Source can be located at: https://github.com/lizmat/User-grent . 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.


grent

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

PORTING CAVEATS

AUTHOR

COPYRIGHT AND LICENSE

User::grent v0.0.4

Authors

License

Dependencies

Test Dependencies

Provides

Documentation