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 Configuration;
use App::RakuCron::Rules;
use App::RakuCron::RuleManager;

sub EXPORT {
    generate-exports App::RakuCron::Rules;
}

sub rcron-manager(App::RakuCron::Rules $rules?) is export {
    my App::RakuCron::RuleManager $manager .= new;
    $manager.add-rules: $_ with $rules;
    $manager.start
}



Still very early stage of development... It doesn't even have tests...


App::RakuCron - Is a cron-like system and module configured in Raku


=begin code :lang<bash>

rcron -e '.run-at: :5hours, :Mon, :Wed, :Fri, { say "running a job" }'

=end code


It's still on early stages of development, everything may change!
App::RakuCron is a cron like system and module written and configured in Raku.
It runs as the user that called it and runs in foreing ground (at least for now).


It uses the L<Configuration raku module|https://github.com/FCO/Configuration>
You can run it with a configuration file (by convention using the C<.rakuconfig> extension, but not required) (as seen on L<./examples/1.rakuconfig>).
Or as string (with C<-e> flag as shown on synopsis)


=begin code :lang<raku>

use App::RakuCron;

await rcron-manager config {
    .run-at: :minutes(* %% 5), :business-days, { say "run on every divisible by 5 minutes on business days" }
}

=end code


C<.run-at> is the most important method, it configures a new job. It can receive many different adverbs:


Defines what year (or years) the job should run on, if nothing else is defined, it will run on the first second of that year(s).
It expects an Int, a List, a Range or a Callable


Defines what month (or months) the job should run on, if nothing else is defined, it will run on the first second of that month(s).
It expects an Int, a List, a Range or a Callable


Defines what day (or days) the job should run on, if nothing else is defined, it will run on the first second of that day(s).
It expects an Int, a List, a Range or a Callable


Defines what hour (or hours) the job should run on, if nothing else is defined, it will run on the first second of that day(s).
It expects an Int, a List, a Range or a Callable


Defines what minute (or minutes) the job should run on, if nothing else is defined, it will run on the first second of that minute(s).
It expects an Int, a List, a Range or a Callable


Defines what second (or seconds) the job should run on.
It expects an Int, a List, a Range or a Callable


Defines what week day (or week days) the job should run on.
It expects an Int, a List, a Range or a Callable


Defines a Callable that will receives a DateTime object as the only parameter and return a Bool meaning it it should run the job or not.


:$delta-minute | :$delta-mins | :$d-minutes | :$d-min | :$d-mins


:$delta-hour | :$delta-hours | :$d-hour | :$$d-hours


:$delta-day | :$delta-days | :$d-day | :$d-days


:$delta-month | :$delta-monthss | :$d-month | :$d-months


:$delta-year | :$delta-years | :$d-year | :$d-years


Defined the minimum time a job should have ran before running it again


:$st-of-the-month | :$nd-of-the-month | :$rd-of-the-month | :$th-of-the-month ) ) ),


:$st-last-of-the-month | :$nd-last-of-the-month | :$rd-last-of-the-month( $th-last-of-the-month ) ) ),


Defines it should on the nth first or last occurrence of that rule on the month


RakuCron

my
class App::Raku::Log:ver<0.0.1>:auth:<zef:lizmat> { };  # for Mi6 only

use RandomColor;

#-------------------------------------------------------------------------------
# Stuff for creating values for templates

# Nicks that shouldn't be highlighted in text, because they probably
# are *not* related to that nick.
my constant %stop-nicks = <
  afraid agree alias all alpha alright also and anonymous any
  args around audience average banned bash beep beta block
  browser byte camelia cap change channels complex computer
  concerned confused connection con constant could cpan
  curiosity curious dead decent delimited dev did direction echo
  else embed engine everything failure fine finger food for fork
  fun function fwiw get good google grew hawaiian hello help hey
  hide his hmm hmmm hope host huh info interested its java jit
  juicy just keyboard kill lambda last life like literal little
  log looking lost mac man manner match max mental mhm mind moar
  moose name need never new niecza nobody nothing old one oops
  panda parrot partisan partly patch perl perl5 perl6 pizza
  promote programming properly pun python question raku rakudo
  rakudobug really regex register release repl return rid robot
  root sad sat signal simple should some somebody someone soon
  sorry space spam spawn spine spot still stop subroutine
  success such synthetic system systems tag tea test tester
  testing tests the there they think this total trick trigger
  try twigil type undefined unix user usr variable variables
  visiting wake was welcome what when who will writer yes
>.map: { $_ => True }

# Create HTML to colorize a word as a nick
sub colorize-nick(Str() $nick, %colors) is export {
    if %colors{$nick} -> $color {
        '<span style="color: ' ~ $color ~ '">' ~ $nick ~ '</span>'
    }
    else {
        $nick
    }
}

# Delimiters in message to find nicks to highlight
my constant @delimiters = ' ', '<', '>', |< : ; , + >;

# Create HTML version of a given entry
sub htmlize($entry, %colors) is export {
    my $text = $entry.^name.ends-with('::Topic')
      ?? $entry.text
      !! $entry.message;

    # Something with a text
    if $entry.conversation {
        # escaping <  > and &
        $text .= subst('&', '&amp;', :global);
        $text .= subst('<', '&lt;',  :global);
        $text .= subst('>', '&gt;',  :global);

        sub strip-protocol($url) {
            with $url.index('://') {
                $url.substr($_ + 3)
            }
            else {
                $url
            }
        }

        # URL linking
        $text .= subst( / https? '://' \S+ /, {
            my $link   := $/.Str;
            '<a href="'
              ~ $link
              ~ '">'
              ~ strip-protocol($link.chars > 55
                  ?? "$link.substr(0,42)...$link.substr(*-10)"
                  !! $link
                )
              ~ '</a>'
        }, :global);

        # Nick highlighting
        if $entry.^name.ends-with("Topic") {
            $text .= subst(/ ^ \S+ /, { colorize-nick($/, %colors) });
        }
        else {
            my str $last-del = ' ';
            $text = $text.split(@delimiters, :v).map(-> $word, $del = '' {
                my $mapped := $word.chars < 3
                  || %stop-nicks{$word.lc}
                  || $last-del ne ' '
                  ?? $word ~ $del
                  !! colorize-nick($word, %colors) ~ $del;
                $last-del = $del;
                $mapped
            }).join;
        }

        # Thought highlighting
        if $entry.^name.ends-with("Self-Reference")
          || $text.starts-with(".oO(") {
            $text = '<div id="thought">' ~ $text ~ '</div>'
        }
    }

    # No text, just do the nick highlighting
    else {
        $text .= subst(/^ \S+ /, { colorize-nick($/, %colors) });

        if $entry.^name.ends-with("Nick-Change") {
            $text .= subst(/ \S+ $/, { colorize-nick($/, %colors) });
        }
        elsif $entry.^name.ends-with("Kick") {
            $text .= subst(/ \S+ $/, { colorize-nick($/, %colors) }, :5th)
        }
    }
    $text
}

# Merge control messages inside the same minute
sub merge-control-messages(@entries) {
    my $merging;
    for @entries.kv -> $index, %entry {
        if !%entry<conversation> {
            if $merging {
                my %params =
                  message => %entry<message>,
                  id      => %entry<relative-target>,
                ;
                with %entry<hh-mm> {
                    %params<hh-mm> = $_;
                }
                else {
                    $merging<control-events>.tail<message> ~= ',';
                }

                $merging<control-events>.push(%params);
                @entries[$index] = Any;
            }
            else {
                $merging := @entries[$index] := Map.new((
                  control-events  => [{
                    hh-mm   => %entry<hh-mm>,
                    message => %entry<message>,
                    id      => %entry<relative-target>,
                  }, ],
                ));
            }
        }
        elsif $merging {
            $merging := Any;
        }
    }
    @entries.grep(*.defined);
}

# Merge messages of a commit together
sub merge-commit-messages(@entries) {
    for @entries.kv -> $index, %entry {
        if %entry<conversation> {
            my $message := %entry<message>;
            with $message.index(": review:")
              // $message.index(": review:") -> int $pos is copy {

                my $prefix := $message.substr(0,++$pos);
                my $nick   := %entry<nick>;
                my int $i   = $index;
                my int @indices = $index;
                while --$i >= 0 && @entries[$i] -> \entry {
                    last if entry<commit>;  # ran into previous commit
                    @indices.unshift($i)
                      if entry<nick> eq $nick
                      && entry<message>.starts-with($prefix);
                }

                if @indices > 1 {
                    my str @targets = @entries[@indices].map: *<relative-target>;
                    my int $first = @indices.shift;
                    with @entries[$first] -> \entry {
                        entry<message> := entry<message>
                          ~  @entries[@indices].map({
                              "<br/>\n&nbsp;&nbsp;" ~ .<message>.substr($pos)
                          }).join;
                        entry<targets> := @targets;
                        entry<commit>  := True;
                    }
                    @entries[$_] := Any for @indices;
                }
            }
        }
    }
    @entries.grep(*.defined);
}

# Merge messages of test-t report together
sub merge-test-t-messages(@entries) {
    my constant @head = <<
      csv-ip5xs csv-ip5xs-20 csv-parser csv-test-xs-20
      test test-t 'test-t --race' test-t-20 'test-t-20 --race'
    >>.sort(-*.chars);
    my constant width = @head[0].chars;
    my constant Tux = '[Tux]' | '[TuxCM]' | '|Tux|';
    my constant test-t-marker = 'Rakudo v';

    sub part-of-test-t($line) {
        return $_ if $line.starts-with($_) for @head;
        Nil
    }

    for @entries.kv -> $index, \entry {
        # An entry by Tux?
        if entry
          && entry<conversation>
          && entry<nick> eq Tux
          && entry<message> -> \message {
            my $nick-used := entry<nick>;

            # The start of a test result stream?
            if message.starts-with(test-t-marker) {

                # Start looking for test result stream.  Allow for up to
                # three messages inbetween.
                my int $i = $index;
                my int $skipped;
                my %tests;
                while @entries[++$i] -> \this-entry {
                    my \this-message := this-entry<message>;
                    if this-entry<nick> eq $nick-used
                      && part-of-test-t(this-message) -> $name {
                        last   # ran into another test result stream
                          if this-message.starts-with(test-t-marker);
                        %tests{$name} := this-message.substr(width).words.List;
                        this-entry = Any;
                        $skipped = 0;
                    }
                    elsif ++$skipped == 3 {
                        last;
                    }
                }
                next unless %tests;  # nothing found

                # Synthesize the new message
                entry<message> := '<table><tr colspan="4">'
                  ~ message
                  ~ "</tr>\n"
                  ~ %tests.sort(*.key).map( -> (:key($name), :value(@times)) {
                    '<tr>'
                      ~ ('<td>' ~ $name ~ '</td>')
                      ~ @times.map({
                          '<td align="right">'
                            ~ $_
                            ~ '</td>'
                        })
                      ~ "</tr>"
                    }).join("\n")
                  ~ '</table>';
                entry<test-t>  := True;
            }
        }
    }
    @entries.grep(*.defined);
}

my str @colors = <<
  white black blue green red brown purple orange yellow
  "bright green" teal "bright cyan" "bright blue" pink grey "bright gray"
>>;

# Simple color control code to span handler
sub control2span($text) {
    my str @parts;
    my int $from;  # will never be at 0
    my $in-span := False;
    while (my $index = $text.index("\x[3]", $from)).defined {
        @parts.push($text.substr($from,$index - $from));
        if $in-span {
            @parts.push('</span>');
            $in-span := False;
        }

        my int $advance = 1;
        my $color = $text.substr($index + 1, 1);
        if "0" le $color le "1" {
            with try $text.substr($index + 1, 2).Int {
                $color = @colors[$_] if 0 <= $_ <= 15;
                ++$advance;
            }
            else {
                $color = @colors[$color.ord - "0".ord];
            }
            ++$advance;
        }
        elsif "2" le $color le "9" {
            $color = @colors[$color.ord - "0".ord];
            ++$advance;
        }
        else {
            $color = "";
        }

        if $color {
            @parts.push(qq/<span style="color: $color">/);
            $in-span := True;
        }
        $from = $index + $advance;
    }
    @parts.push($text.substr($from));
    @parts.push('</span>') if $in-span;
    @parts.join
}

# Check for invocations of Camelia, assume it's code
sub mark-camelia-invocations(@entries --> Nil) {
    for @entries -> \entry {
        if entry<conversation> && entry<message> -> \message {
            if message.starts-with('m: ') {
                entry<runcode-link> :=
                  "/" ~ entry<channel> ~ "/run.html?" ~ entry<target>;
            }
            else {
                with message.index(': OUTPUT: «') -> $index {
                    entry<camelia> := message.substr(0,$index);
                    my str $output  = message.substr($index + 11, *-1);
                    $output = $output.chop if $output.ends-with("␤");
                    $output = control2span($output);
                    entry<message> := $output.subst("␤", "<br/>", :global);
                }
                orwith message.index(': ( no output )') -> $index {
                    entry<camelia> := message.substr(0,$index);
                    entry<message> := message.substr($index + 2);
                }
            }
        }
    }
}

sub live-plugins() is export {
    my constant @live-plugins =
      &mark-camelia-invocations,
    ;
}

sub day-plugins() is export {
    my constant @day-plugins =
      &merge-commit-messages, 
      &merge-test-t-messages, 
      &merge-control-messages,
      &mark-camelia-invocations,
    ;
}

sub descriptions($io) is export {
    $io.dir.map: { .basename => .slurp.chomp }
}



App::Raku::Log - Cro application for presenting Raku IRC logs


=begin code :lang<raku>

$ ./start

$ ./start logs base

=end code


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


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

AUTHOR

COPYRIGHT AND LICENSE

App::Raku::Log v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation