Image

head

code

item

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

class X::PublicSuffix::BadDomain is Exception {
    has $!host    is built;
    has $!message is built;

    method message {
        "Invalid host name '{ $!host.gist }': it $!message";
    }
}

package PublicSuffix:ver<0.0.20220703>:auth<zef:jjatria> {
    # Parse file once and cache on compilation
    my %RULES = BEGIN {
        gather for %?RESOURCES<public_suffix_list.dat>.lines {
            next if .not or .starts-with: '//';
            take ~$<rule> => 'e' when / ^ '!'  $<rule> = \S+ /;
            take ~$<rule> => 'w' when / ^ '*.' $<rule> = \S+ /;
            take ~$<rule> => 'i' when / ^      $<rule> = \S+ /;
        }
    }

    my sub to-unicode ( Str:D $_ --> Str ) is hidden-from-backtrace {
        use IDNA::Punycode;
        lc .contains('xn--') ?? .split('.')».&decode_punycode.join: '.' !! $_
    }

    my sub to-ascii ( Str:D $_ --> Str ) is hidden-from-backtrace {
        use IDNA::Punycode;
        .contains('xn--') ?? $_ !! .split('.')».&encode_punycode.join: '.'
    }

    my sub validate ( Str $_ --> True ) is hidden-from-backtrace {
        # As per https://datatracker.ietf.org/doc/html/rfc1035#section-2.3.4
        # See also https://devblogs.microsoft.com/oldnewthing/?p=7873

        my $message;
        $message ||= do 'must be a non-empty string'         if .not;
        $message ||= do 'must not start with period (.)'     if .starts-with: '.';
        $message ||= do 'must not have more than 253 octets' if .encode.elems > 253;
        $message ||= do 'must have labels with between 1 and 63 octets'
            unless .split('.')».encode».elems.all ~~ 1 .. 63;

        X::PublicSuffix::BadDomain.new( host => $_, :$message).throw if $message;
    }



PublicSuffix - Query Mozilla's Public Suffix List


=begin code :lang<raku>
use PublicSuffix;

# The effective TLD of a host name
say public-suffix 'www.example.com';
# OUTPUT: com

# New TLDs are valid public suffix by default
say public-suffix 'www.example.unknownnewtld';
# OUTPUT: unknownnewtld

# Accept host names in Unicode
say public-suffix 'www.example.香港';
# OUTPUT: 香港

# Accept host names in punycode
say public-suffix 'www.example.xn--j6w193g';
# OUTPUT: xn--j6w193g

# Shortest domain that can be registered
say registrable-domain 'www.example.com';
# OUTPUT: example.com

# Returns a type object if registrable domain is not found
say registrable-domain 'com';
# OUTPUT: (Str)
=end code


This module provides functions to query Mozilla's
L<Public Suffix List|http://publicsuffix.org>: a community-maintained
list of domain name suffixes. The data in this list can be used to determine
the effective top-level domain of a host name, or to test whether two hosts
share an origin, as well as other similar validation functions. This most
commonly used when validating the scope of HTTP cookies to prevent
L<supercookies|https://en.wikipedia.org/wiki/Supercookie>, but it has
L<a variety of other uses|https://publicsuffix.org/learn>.


The functions described below take host names as their parameter, and run
some validation on their input before processing. When given a malformed or
otherwise invalid host name, the functions below will throw a
X::PublicSuffix::BadDomain exception with the reason for the failure as its
C<message>.


For a domain to be valid, it must be a non-empty string, with a maximum
length of 253 octets, and no more than 63 octets per label.


Domains can be provided as either UTF-8 strings or their ASCII punycoded
variants. The returned strings will use the format of the strings provided.
In other words, if you provide a UTF-8 string, you will receive a UTF-8
string back, while giving an ASCII string will generate an ASCII string in
return.


Providing partially punycoded strings is not supported, and the behaviour
of these functions with that input is undefined.


=begin code :lang<raku>
sub public-suffix ( Str $host ) returns Str
=end code


Takes a host name as a Str and returns the
L<public suffix|https://url.spec.whatwg.org/#host-public-suffix> for that
host, or the type object if no public-suffix is found or if the host is the
string representation of a IPv4 or IPv6 address. This function will throw a
X::PublicSuffix::BadDomain exception if the host name is not valid.


According to
L<§ 3.2 of the URL living standard|https://url.spec.whatwg.org/#host-miscellaneous>,
the public suffix is "the portion of a host which is included on the Public
Suffix List".



    our sub public-suffix ( Str $host is copy --> Str ) is export {
        validate $host;

        return Str
            if $host.contains(':')                               # IPv6: contains a ':'
            || $host ~~ /^ [ <[ 0..9 ]> ** 1..3 ] ** 4 % '.' $/; # IPv4

        my $punycode = ( $host // '' ).contains: 'xn--';
        $host .= &to-unicode;

        my $suffix;
        while $host {
            my $rhs = $host.split( '.', 2 ).tail;

            $suffix = do with %RULES{$host} {
                when 'i' { $host }
                when 'w' { Str   }
                default  { $rhs  }
            }
            elsif $host eq $rhs {
                # We are down to a single part that matches no rules
                # Assume it's a new valid TLD
                $rhs.split('.').tail;
            }
            elsif %RULES{$rhs} -> $_ {
                when 'w' { $host                     }
                when 'i' { $rhs                      }
                default  { $rhs.split( '.', 2 ).tail }
            }

            last if $suffix || $host eq $rhs;

            $host = $rhs;
        }

        $punycode ?? $suffix.&to-ascii !! $suffix;
    }



=begin code :lang<raku>
sub registrable-domain ( Str $host ) returns Str
=end code


Takes a host name as a Str and returns the
L<registrable domain|https://url.spec.whatwg.org/#host-registrable-domain>
for that host, or the type object if no registrable domain is found or if the
host is the string representation of a IPv4 or IPv6 address. This function
will throw a X::PublicSuffix::BadDomain exception if the host name is not
valid.


According to
L<§ 3.2 of the URL living standard|https://url.spec.whatwg.org/#host-miscellaneous>,
the registrable domain of a host is "the most specific public suffix, along
with the domain label immediately preceding it, if any".



    our sub registrable-domain ( Str $host is copy --> Str ) is export {
        validate $host;

        my $punycode = ( $host // '' ).contains: 'xn--';
        $host .= &to-unicode;

        my $tld = public-suffix $host;
        return Str unless $tld && $host ne $tld;

        my $rest = $host.substr( 0, * - $tld.chars - 1 ).split('.').tail;

        $punycode ?? .&to-ascii !! $_ given "$rest.$tld"
    }
}



The code in this distribution takes inspiration from a number of similar
Perl libraries. In particular:


In addition to the distributions mentioned above, the API was mostly
inspired by the L<publicsuffixlist|https://pypi.org/project/publicsuffixlist>
Python module by ko-zu.


This module owes a debt of gratitude to their authors and those who have
contributed to them, and to their choice to make their code and work
publicly available.


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


PublicSuffix

use Test;

unit module PSpec:ver<4.0.1>:auth<zef:raku-community-modules>;

## Perform a block of code x number of times.
multi sub infix:<times>(Int $num, &closure) is export {
    for ^$num { closure() }
}

## Same thing, just the other way around.
sub infix:<xxx>(&closure, Int $num) is export {
    $num times &closure;
}

## Returns the output of a test to describe.
sub infix:<should>($got, $want) is export {
    $want ~~ Callable
      ?? $want($got)
      !! ($got, $want)
}

## eq, the most basic test possible. The same as passing the raw value.
sub eq($val) is export { $val }

## gt, is a value greater than?
sub gt(Numeric $want) is export { * > $want }

## lt, is a value lesser than?
sub lt(Numeric $want) is export { * < $want }

# Public function: describe ($class_name, $method_name, @tests)
# Implements a describe statement inspired by the one from RSpec.
# The @tests array must contain Pair objects, where the key is the
# name of the test, and the value is a closure containing the actual
# test to perform. The output must be sent by the 'should' operator.
#
#     describe "PSpec", "times", [
#         'operator works' => {
#             my $value = 0;
#             20 times { $value++ }
#             return $value, 20;
#         },
#     ];
#

sub describe($class, $name, @tests) is export {
    for @tests -> $pair {
        my $sub := $pair.value;
        my @return = $sub();
        my $test = "$class.$name: {$pair.key}";
        if @return.elems == 1 {
            ok @return[0], $test;
        }
        elsif @return.elems == 2 {
            is @return[0], @return[1], $test;
        }
        else {
            die "invalid test paramters";
        }
    }
}



PSpec - An RSpec-like testing framework for Raku


=begin code :lang<raku>

use PSpec;

=end code


PSpec is an implementation of Ruby's RSpec library, in Raku.
It's currently very minimal, and does not implement much of RSpec.


Lots. This is barely functional, but is pretty much back to the level of
the last working version prior to the rewrite.


Well, I must send kudos to the original authors of RSpec and Cucumber,
without them, this wouldn't exist.


Also, a big cheers to Carl Masak, who is always friendly and helpful!
And a call-out to Larry Wall whose help on the #raku channel has been 
greatly appreciated! I guess I should also thank him for creating Perl :-)


Since writing the original version of this Credits section, I've received
a lot of help and feedback from many people on the #raku channel. Thanks
to the whole Raku community for being awesome!


Source can be located at: https://github.com/raku-community-modules/PSpec .
Comments and Pull Requests are welcome.


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


PSpec

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

STATUS

TODO

CREDITS

AUTHOR

COPYRIGHT AND LICENSE

PSpec v4.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation