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

unit module Moneys;

constant %prefix-currency-sigils = {
    # currencies named dollar
    'USD' => '$',
    'AUD' => '$',
    'CAD' => '$',
    'BSD' => '$',
    'BZD' => '$',
    'BSD' => '$',
    'BMD' => '$',
    'BND' => '$',
    'KYD' => '$',
    'XCD' => '$',
    'FJD' => '$',
    'GYD' => '$',
    'HKD' => '$',
    'JMD' => '$',
    'KID' => '$',
    'LRD' => '$',
    'NAD' => '$',
    'SGD' => '$',
    'SBD' => '$',
    'SRD' => '$',
    'TWD' => '$',
    'TTD' => '$',
    'TVD' => '$',

    # Pesos use the dollar sign too
    # TODO: add more
    'MXN' => '$',

    # Brazilian real uses dollar sign
    'BRL' => '$',

    # Currencies named pound or similar (excluding the Turkish Lira)
    'GBP' => '£',

    'EUR' => '€',

}

my token currency-sign { <[\$€£]> }
my token decimal { <[\d+]> }
my regex money-amount { <decimal>* '.' <decimal>+ }
my token currency-code { <:Lu> ** 3 }
my regex money-regex {
    <currency-sign>?
    <money-amount>
    \h*
    <currency-code>
}




class Money is export {
    has Rat $.amount is required;
    has Str $.currency is required;

    multi method new(Str $input) {
        if $input ~~ /<money-regex>/ {
            self.bless(amount => $<money-regex><money-amount>.Rat, currency => $<money-regex><currency-code>.Str);
        } else {
            fail { "Not a valid money string input" };
        }
    }

    multi method new(Rat :$amount, Str :$currency) {
        self.bless(:$amount, :$currency)
    }

    multi method new(Rat $amount, Str $currency) {
        self.bless(:$amount, :$currency)
    }

    multi method abs {
        Money.new($!amount.abs, $!currency)
    }

    method gist {
        my Str $prefix = %prefix-currency-sigils{$.currency} || '';

        sprintf("%s%.2f %s", $prefix, $!amount, $!currency);
    }

    method Str {
        my Str $prefix = %prefix-currency-sigils{$.currency} || '';

        sprintf("%s%.2f %s", $prefix, $!amount, $!currency);
    }

    method is-negative { $!amount < 0.0 }

    method is-positive { $!amount > 0.0 }
}

multi sub money(Str $input) is export {
    if $input ~~ /<money-regex>/ {
        Money.new(amount => $<money-regex><money-amount>.Rat, currency => $<money-regex><currency-code>.Str);
    } else {
        fail { "Not a valid money string input" };
    }
}

multi sub money(Rat $amount, Str $currency --> Money) is export {
    Money.new(:$amount, :$currency)
}

multi sub infix:<+>(Money $a, Money $b) is export {
    fail "Currencies must be the same in order to add value. Got $($a.currency) and $($b.currency)" \
        if $a.currency ne $b.currency;

    Money.new(amount => $a.amount + $b.amount, currency => $a.currency);
}

multi sub infix:<+>(Money $a, Rat $b) is export {
    Money.new(amount => $a.amount + $b, currency => $a.currency);
}

multi sub infix:<->(Money $a, Money $b) is export {
    fail "Currencies must be the same in order to subtract. Got $($a.currency) and $($b.currency)" \
        if $a.currency ne $b.currency;

    Money.new(amount => $a.amount - $b.amount, currency => $a.currency);
}

multi sub infix:<->(Money $a, Rat $b) is export {
    Money.new(amount => $a.amount - $b, currency => $a.currency);
}

multi sub infix:<->(Money $a, Int $b) is export {
    Money.new(amount => $a.amount - $b, currency => $a.currency);
}

multi sub prefix:<->(Money $a) is export {
    Money.new(-$a.amount, $a.currency)
}

multi sub infix:<cmp>(Money $a, Money $b) is export {
    fail "Currencies must be the same in order to compare. Got $($a.currency) and $($b.currency)" \
        if $a.currency ne $b.currency;

    $a.amount cmp $b.amount
}

multi sub infix:<*>(Money $a, Rat $b) is export {
    Money.new(amount => $a.amount * $b, currency => $a.currency);
}

multi sub infix:<*>(Money $a, Int $b) is export {
    Money.new(amount => $a.amount * $b, currency => $a.currency);
}

multi sub infix:</>(Money $a, Rat $b) is export {
    Money.new(amount => $a.amount / $b, currency => $a.currency);
}

multi sub infix:</>(Money $a, Int $b) is export {
    Money.new(amount => $a.amount / $b, currency => $a.currency);
}


Moneys

use XML;

use Module2Rpm::Role::Internet;
use Module2Rpm::Package;



More Infos
    L<https://build.opensuse.org/apidocs/index>


create-package(Module2Rpm::Package :$package)


Creates a package via API at https://build.opensuse.org


upload-files(Module2Rpm::Package :$package!)


Uploads the source tar archive file and the spec file of a package.



class Module2Rpm::Upload::OBS {
    has Module2Rpm::Role::Internet $.client is required;
    has $.project is required;
    has Set $.packages;
    has $.api-url = 'https://api.opensuse.org';

    method package-exists(Str $package-name --> Bool) {
        self.get-packages();
        return $!packages{$package-name};
    }

    method create-package(Module2Rpm::Package :$package) {
        # Have to filter the description otherwise special characters like $ will break
        # the api.opensuse.org verifying check:
        # <status code="validation_failed">
        #  <summary>package validation error: 3:36: FATAL: xmlParseEntityRef: no name</summary>
        #</status>
        my $description = $package.spec.get-summary();
        $description ~~ s:g/<-[\s \w]>+//;

        my $xml = qq:to/END/;
        <package name="{$package.module-name}" project="$!project">
            <title>{$package.module-name}</title>
            <description>{$description}</description>
        </package>
        END
        my $url = $!api-url ~ "/source/" ~ $!project  ~ "/" ~ $package.module-name ~ "/_meta";
        $!client.put($url, content-type => "application/xml", body => $xml);
    }

    method delete-package(Module2Rpm::Package :$package!) {
        my $url = $!api-url ~ "/source/" ~ $!project ~ "/" ~ $package.module-name;
        $!client.delete($url);
    }

    method delete-all-packages() {
        self.get-packages();
        for $!packages.keys -> $package {
            say "Delete $package";
            my $url = $!api-url ~ "/source/" ~ $!project ~ "/" ~ $package;
            $!client.delete($url);
        }
    }

    method upload-files(Module2Rpm::Package :$package!) {
        if not self.package-exists($package.module-name) {
            say "Create package {$package.module-name}";
            self.create-package(:$package);
        }

        my $url-source-archive = $!api-url ~ "/source/" ~ $!project ~ "/" ~ $package.module-name ~ "/" ~ $package.tar-name;
        my $url-spec-file = $!api-url ~ "/source/" ~ $!project ~ "/" ~ $package.module-name ~ "/" ~ $package.spec-file-name;

        my $tar-archive-binary-content = $package.tar-archive-path.slurp(:bin, :close);
        my $spec-file-content = $package.spec-file-path.slurp(:close);

        say "{$package.module-name}: Upload tar archive file";
        $!client.put($url-source-archive, content-type => "application/octet-stream", body => $tar-archive-binary-content);
        say "{$package.module-name}: Upload spec file";
        $!client.put($url-spec-file, body => $spec-file-content);
    }

    method get($url = "" --> XML::Document) {
        my $body = $!client.get($url);

        if $body ~~ Buf {
            my $str = $body.decode;
            return from-xml($str);
        }

        if $body ~~ Str {
            return from-xml($body);
        }

        die "Unknown type received: {$body.WHAT}";
    }

    method get-packages() {
        return $!packages if $!packages.defined;

        my $xml = self.get($!api-url ~ "/source/" ~ $!project);
        my @packages;
        for $xml.root -> $note {
            for $note.elements -> $element {
                @packages.push: $element.attribs<name>;
            }
        }

        $!packages = Set.new(@packages);
    }
}


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

Module2Rpm v0.0.3

Authors

License

Dependencies

Test Dependencies

Provides

Documentation