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

## A simple HTTP Daemon role. Inspired by HTTP::Server::Simple
## See HTTP::Easy::PSGI as the default daemon class implementation.

use HTTP::Status;

unit role HTTP::Easy;

has Int:D  $.port   = 8080;
has Str:D  $.host   = '0.0.0.0';
has Bool:D $.debug  = False;
has Bool:D $.silent = False;
has        $!listener;
has        $.connection;    # To be populated by accept().
has        %.env;           # The environment, generated by run().
has        $.http-protocol; # The HTTP version being used.
has        $.body;          # Any request body, populated by run().

## If set to true, we will read the body even if there is no CONTENT_LENGTH.
has Bool $.always-get-body = False;

my constant CRLF             is export = "\x0D\x0A";
my constant DEFAULT_PROTOCOL is export = 'HTTP/1.0';

## We're using DateTime.new(time) instead of DateTime.now()
## Because the current DateTime messes up the user's local timezone
## if they are in a negative offset, which totally screws up the reported
## time, so we are forcing UTC instead.
method message($message --> Nil) {
    note "[{DateTime.now}] $message" unless $.silent;
}

method connect(:port($localport) = $.port, :host($localhost) = $.host) {
    $!listener := IO::Socket::INET.new: :$localhost, :$localport, :listen
}

method run() {
    $!debug = ?%*ENV<HTTP_EASY_DEBUG>;

    self.connect unless $!listener;
    self.message('Started HTTP server.');
    self.pre-connection;
    while $!connection = $!listener.accept {
        self.message("Client connection received.")
          if $!debug;

        self.on-connection;

        my $first-chunk;
        my $msg-body-pos;

        while $!connection.recv(:bin) -> $t {
            self.message("Received a chunk of $t.elems() bytes length")
              if $!debug;

            if $first-chunk.defined {
                $first-chunk = $first-chunk ~ $t;
            }
            else {
                # overwhelmingly often (for simple GET requests, for example) we'll
                # get all data in one run through this loop.
                $first-chunk = $t;
            }

            # Find the header/body separator in the chunk, which means we can parse
            # the header seperately and are able to figure out the
            # correct encoding of the body.

            my int $look_position = 0;
            my int $end_of_buffer = $first-chunk.elems;

            while $look_position < $end_of_buffer - 3 {
                if $first-chunk.AT-POS($look_position) == 13
                  && $first-chunk.AT-POS($look_position + 1) == 10
                  && $first-chunk.AT-POS($look_position + 2) == 13
                  && $first-chunk.AT-POS($look_position + 3) == 10 {
                    $msg-body-pos = $look_position + 2;
                    last;
                }
                else {
                    $look_position = $look_position + 1;
                }
            }

            last if $msg-body-pos;
        }

        without $first-chunk {
            # if we're here, that means our recv timed out.
            # browsers will sometimes open a connection even though there is no
            # request to send yet, to make the next request faster.
            # since we have to be parrot-compatible, we can't use async
            # features, so we'll have to do it the nasty, time-out way.
            self.message("thrown out a connection that sent no data.")
              if $!debug;
            $!connection.close;
            next;
        }

        $!body = $first-chunk.subbuf($msg-body-pos + 2);

        my $preamble = $first-chunk.subbuf(0, $msg-body-pos).decode('ascii');

        self.message("Read preamble:\n$preamble\n--- End of preamble.")
          if $!debug;

        ## End of work around.
        my @headers = $preamble.split("\r\n");
        my $request = @headers.shift;
        without $request {
            self.message("Client connection lost.")
              if $!debug;
            $!connection.close;
            next;
        }
        self.message($request);

        self.message("Finished parsing headers: @headers.raku()")
          if $!debug;

        my ($method, $uri, $protocol) = $request.words;
        $protocol = DEFAULT_PROTOCOL without $protocol;

        unless $method eq 'GET' | 'POST' | 'HEAD' | 'PUT' | 'DELETE' | 'PATCH' {
            $!connection.print(self.unhandled-method);
            $!connection.close;
            next;
        }
        $!http-protocol = $protocol;

        %!env = (); ## Delete the previous hash.
        my ($path, $query) = $uri.split('?', 2);
        $query //= '';

        ## First, let's add our "known" headers.
        %.env<SERVER_PROTOCOL> = $protocol;
        %.env<REQUEST_METHOD>  = $method;
        %.env<QUERY_STRING>    = $query;
        %.env<PATH_INFO>       = $path;
        %.env<REQUEST_URI>     = $uri;
        %.env<SERVER_NAME>     = $.host;
        %.env<SERVER_PORT>     = $.port;
        ## Next, let's add HTTP request headers.
        for @headers -> $header {
            my ($key, $value) = $header.split(': ');
            if $key.defined and $value.defined {
                $key ~~ s:g/\-/_/;
                $key .= uc;
                $key = 'HTTP_' ~ $key unless $key eq 'CONTENT_LENGTH' | 'CONTENT_TYPE';
                if %!env{$key} :exists {
                    %!env{$key} ~= ", $value";
                }
                else {
                    %!env{$key} = $value;
                }
            }
        }

        # Use CONTENT_LENGTH to determine the length of data to read.
        if %.env<CONTENT_LENGTH>:exists {
            if %.env<CONTENT_LENGTH> {
                while %.env<CONTENT_LENGTH> > $!body.bytes {
                    $!body ~= $!connection.recv(%.env<CONTENT_LENGTH> - $!body.bytes, :bin);
                }
#                self.message("Got body: "~$!body.decode) if $!debug;
            }
        }
        elsif $.always-get-body {
            ## No content length. Keep reading until no data is sent.
            while my $read = $!connection.recv(:bin) {
                $!body ~= $read;
            }
        }

        ## Call the handler. 
        ##
        ## If it returns a defined value, it is assumed to be a valid HTTP 
        ## response, in the form of a Str(ing), a Buf, or an object that
        ## can be stringified.
        ##
        ## If it returns an undefined value, we assume the handler
        ## sent the response to the client directly, and end the session.
        with self.handler -> $res {
            $res ~~ Buf
              ?? $!connection.write($res)
              !! $!connection.print($res.Str);
        }
        $!connection.close;
        self.closed-connection;
        self.message("Client connection closed.")
          if $!debug;
    }
    self.finish-connection;
    self.message("Connection finished. Server closed.")
      if $!debug;
}

## Stub methods. Replace with your own.
method pre-connection            {}; ## Runs prior to waiting for connection.
method on-connection             {}; ## Runs at the beginning of each connection.
method closed-connection     {}; ## Runs after closing each connection.
method finished-connection {}; ## Runs when the wait loop is ended.

## The handler method, this MUST be defined in your class.
method handler {...};

## Feel free to override this in your class.
method unhandled-method() {
    my $status  := 501;
    my $message := get_http_status_msg($status);
    "$.http-protocol $status $message";
}



HTTP::Easy - HTTP servers made easy, including PSGI


=begin code :lang<raku>

use HTTP::Easy;

=end code


Raku libraries to make HTTP servers easily. 


This was inspired by C<HTTP::Server::Simple>, but has a very different
internal API, and extended functionality. It's been designed to work well
with the C<Web::App> and C<SCGI> libraries.


A role to build HTTP daemon classes with.  This provides the framework
for parsing HTTP connections.


A class consuming the C<HTTP::Easy> role. This builds a PSGI environment,
and passes it onto a handler. The handler must return a C<PSGI> response:


=begin code :lang<raku>

[ $status, @headers, @body ]

=end code


This can be used as an engine in the C<Web::App> library.


=begin code :lang<raku>

use HTTP::Easy::PSGI;
my $http = HTTP::Easy::PSGI.new(:port(8080));
  
my $app = sub (%env) {
    my $name = %env<QUERY_STRING> || "World";
    [ 200, [ 'Content-Type' => 'text/plain' ], [ "Hello $name" ] ]
}

$http.handle($app);

=end code


Implement HTTP/1.1 features such as Transfer-Encoding, etc.


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


Easy

unit class HTML::Template;

use Text::Escape;
use HTML::Template::Grammar;



HTML::Template - A simple templating system based on the HTML::Template of Perl 5


my %params = (
  title => 'Hello Perl 6 world',
  authors => Array.new(
    { name => 'Ilya'   },
    { name => 'Moritz' },
    { name => 'Lyle'   },
    { name => 'Carl'   },
    { name => 'Johan'  },
  ),
);


my $ht = HTML::Template.from_file("templates/index.tmpl");
$ht.with_params(%params);
print $ht.output;


eg/templates/index.tmpl looks like this:


<TMPL_IF error>
 <div id="error">Some error happened</div>
</TMPL_IF>



has $.in;
has %!params;
has %!meta;
has $.file;

method from_string( Str $in ) {
    return self.new(in => $in);
}

method from_file($file_path) {
    return self.new(in => slurp($file_path), file => $file_path);
}

method param( Pair $param ) {
    %!params{$param.key} = $param.value;
}

method with_params( %params ) {
    %!params = %params;
    return self;
}

method output() {
    return self.substitute( self.parse, %!params );
}

method parse( $in? ) {
    my $match := HTML::Template::Grammar.parse($in || $!in);
    die "Failed to parse the template" unless $match;
    CATCH {
        default {
            my $err = $_;
            die $err ~ ($.file ?? " in file $.file" !! "");
        }
    }
    #die "Failed to parse the template" ~ ($.file ?? " in file $.file" !! "") unless $match;
    return $match<contents>;
}

method substitute( $contents, %params ) {
    my $output = ~$contents<plaintext>;

    for $contents<chunk>.list -> $chunk {

        if $chunk<directive><insertion> -> $i {
            my $key = ~$i<attributes><name><val>;

            my $value;
            if (defined %params{$key}) {
                $value = %params{$key};
            } else {
                $value = %!params{$key};
            }

            # RAKUDO: Scalar type not implemented yet
            if defined $value {
                warn "Param $key is a { $value.WHAT }" unless $value ~~ Str | Int;
            } else {
                #warn "Param $key is a undef";
                $value = '';
            }

            if $i<attributes><escape> {
                my $et = ~$i<attributes><escape>;
                $value = escape($value, $et);
            }
            $output ~= ~$value;
        }
        elsif $chunk<directive><if_statement> -> $if {
            my $cond;
            if $if<attributes><name><lctrls> -> $lc {
                if %!meta<loops><current> -> $c {
                    if $lc<lc_last> {
                        $cond = ?($c<elems> == $c<iteration>);
                    }
                    elsif $lc<lc_first> {
                        $cond = ?($c<iteration> == 1);
                    }
                }
            }
            else {
                $cond = %params{~$if<attributes><name><val>};
            }

            if $cond {
                $output ~= self.substitute(
                                $if<contents>[0],
                                %params
                            );
            }
            elsif $if<else> {
                $output ~= self.substitute(
                                $if<else>,
                                %params
                            );
            }
        }
        elsif $chunk<directive><for_statement> -> $for {
            my $key = ~$for<attributes><name><val>;

            my $iterations = %params{$key};

            # RAKUDO: Rakudo doesn't understand autovivification of multiple
            # hash indices %!meta<loops><current> = $key; [perl #61740]
            %!meta<loops> = {} unless defined %!meta<loops>;

            # that will fail on nested same-named loops... hm
            %!meta<loops>{$key} = {elems => $iterations.elems, iteration => 0};
            %!meta<loops><current> = %!meta<loops>{$key};

            for $iterations.values -> $iteration {
                %!meta<loops>{$key}<iteration>++;
                $output ~= self.substitute(
                                $for<contents>,
                                $iteration
                            );
            }
        }
        elsif $chunk<directive><include> {
            my $file = ~$chunk<directive><include><attributes><name><val>;
            %params<TMPL_PATH> = '' if not defined %params<TMPL_PATH>;
            $file = %params<TMPL_PATH> ~ $file;
            # TODO: check for file existance
            #if $file ~~ :e  {
                $output ~= self.substitute(
                                self.parse( slurp($file) ),
                                %params
                            );
            #}
        }

        $output ~= ~$chunk<plaintext>;
    }
    return $output;
}

# vim:ft=perl6


Template

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

A simple almost-port of CPAN's HTML::Template to Raku

License information

TODO

Authors

HTML::Template v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation