head

Image

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

unit package URI::Query::FromHash:auth<zef:raku-land>:ver<0.0.1>;

my regex reserved { < [ ; / * ' ! ? : @ & = + , $ \[ \] ( ) % \\                        ]> }
my regex    other { <-[ ; / * ' ! ? : @ & = + , $ \[ \] ( ) % \\ _ . ~ A..Z a..z 0..9 - ]> }

my %escapes = BEGIN (^256).map: {
    .&chr ~~ /<[ . ~ A..Z a..z 0..9 - ]>/
        ?? Empty !! .&chr => .fmt: '%%%02X';
}

my sub escape ( $_, &class = &reserved --> Str ) {
    return '' unless .defined;
    .Str.subst( :g, /<&class>/, { .encode».&{ %escapes{$_} // .fmt: '%%%02X' }.join } )
        .trans: ' ' => '+';
}

proto hash2query ( |c --> Str ) is export {*}

multi hash2query ( Any:U $ --> '' ) { }

multi hash2query ( Any:D $input --> Str ) {
    CATCH { return '' when X::Hash::Store::OddNumber }
    my Hash() $hash = $input;

    return '' unless $hash.elems;

    my $query = join '&', $hash.pairs.sort(*.key).map: -> ( :$key, :$value ) {
        $value.List.map: { $key.&escape ~ '=' ~ .&escape }
    }

    escape $query, &other;
}



URI::Query::FromHash - Construct a query string from a hash


=begin code :lang<raku>
use URI::Query::FromHash;

say hash2query {
   foo  => 'bar',
   baz  => < qux quux >,
   utf8 => '🦋',
}
# OUTPUT:
# baz=qux&baz=quux&foo=bar&utf8=%F0%9F%A6%8B
=end code


URI::Query::FromHash aims to be a fast, light query string constructor.


Inspired by L<the Perl module of the same name|https://metacpan.org/pod/URI::Query::FromHash>
and Ruby on Rails' L<to_query|http://api.rubyonrails.org/classes/Hash.html#method-i-to_query>
hash method.


=begin code :lang<raku>
sub hash2query ( Hash() $hash --> Str )
=end code


Accepts anything that can be coerced to a Hash of query parameters and
returns a Str suitable to be used as the query parameters of a URI. Values
will be coerced to List and iterated over, with every element being coerced
to Str before processing. Every one of these elements will then be
URL-encoded and will appear in the generated string once preceded by the
corresponding URL-encoded key and an equal sign (C<=>).


Pairs in the input Hash will be processed alphabetically by key.


When this function encounters input it cannot handle, it returns the empty
string, meaning it should always be safe to use.


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


FromHash

URI::FetchFile - retrieve a file from the internet by any means necessary


=begin code

use URI::FetchFile;

if fetch-uri('http://rakudo.org/downloads/star/rakudo-star-2016.10.tar.gz', 'rakudo-star-2016.10.tar.gz') {
    # do something with the file
}
else {
    die "couldn't get file";
}

=end code


This provides a simple method of retrieving a single file via HTTP using the
best available method whilst trying to limit the dependencies.


It is intended to be used by installers or builders that may need to retrieve
a file but otherwise have no need for an HTTP client.


It will try to use the first available method from:


item

Failing with a C<X::NoProvider> if it can't use any of them.


sub fetch-uri(Str $uri, Str $file ) returns Bool is export(:DEFAULT)


This will attempt to get the resource identified by URI and save the
returned resource in the specified $file.  If the resource cannot be
retrieved then this will return False (and the file won't be created.)
If none of the providers are available an exception will be thrown.



class URI::FetchFile {

    role Provider {
        method fetch(Provider:U: :$uri, :$file --> Bool ) {
            ...
        }

        method is-available( --> Bool ) {
            ...
        }
    }

    role Class[Str $class-name] {
        my $type;
        method class-name( --> Str ) {
            $class-name;
        }

        my Bool $tried = False;

        method type( --> Mu ) {
            if ! $tried {
                $type = try require ::($class-name);
            }
            $type;
        }

        method is-available( --> Bool ) {
            not $.type === Any;
        }
    }

    class Provider::LWP::Simple does Class['LWP::Simple'] does Provider {
        method fetch(:$uri, :$file --> Bool ) {
            my Bool $rc = False;

            if $.is-available {
                $rc = $.type.getstore($uri, $file);
            }
            $rc;
        }
    }

    class Provider::HTTP::UserAgent does Class['HTTP::UserAgent'] does Provider {
        method fetch(:$uri, :$file --> Bool ) {
            my Bool $rc = False;
            if $.is-available {
                my $res =  $.type.new.get($uri);
                if $res.is-success {
                    my $out = $file.IO.open(:w);
                    if $res.is-binary {
                        $out.write: $res.content;
                    }
                    else {
                        $out.print: $res.content;
                    }
                    $out.close;
                    $rc = True;
                }
            }
            $rc;
        }
    }

    role Executable[Str $executable-name] {

        my Str $executable;

        method executable-name( --> Str ) {
            $executable-name;
        }

        method executable( --> Str ) {
            if ! $executable.defined {
                $executable = which($executable-name) // Str;
            }
            $executable;
        }

        method is-available( --> Bool ) {
            so $.executable;
        }

    }

    class Provider::Curl does Executable['curl'] does Provider {
        method fetch(:$uri, :$file --> Bool ) {
            my $rc = False;
            if $.is-available {
                my $p = run($.executable,'-f', '-s', '-o', $file, $uri );
                if !$p.exitcode {
                    $rc = True;
                }
            }
            return $rc;
        }
    }

    class Provider::Wget does Executable['wget'] does Provider {
        method fetch(:$uri, :$file --> Bool ) {
            my $rc = False;
            if $.is-available {
                my $p = run($.executable,'-q', '-O', $file, $uri );
                if !$p.exitcode {
                    $rc = True;
                }
                else {
                    # wget will create the file even if it doesn't retrieve anything
                    $file.IO.unlink if $file.IO.e;
                }
            }
            return $rc;
        }
    }

    class X::NoProvider is Exception {
        method message( --> Str ) {
            "No working provider can be found to fetch file";
        }
    }

    my @providers = (Provider::HTTP::UserAgent, Provider::LWP::Simple, Provider::Curl, Provider::Wget);

    method set-providers(*@new-providers) {
        @providers = @new-providers.grep(Provider);
    }

    sub fetch-uri(Str $uri, Str $file --> Bool ) is export(:DEFAULT) {
        my Bool $rc = False;

        my Int $tried = 0;
        for @providers -> $provider {
            if $provider.is-available {
                $rc = $provider.fetch(:$uri, :$file);
                last;
            }
            else {
                $tried++;
            }
        }
        if $tried == @providers.elems {
            X::NoProvider.new.throw;
        }
        $rc;
    }
}
# vim: expandtab shiftwidth=4 ft=raku


FetchFile

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

URI-FetchFile

image i_github_com_jonathanstowe_uri_fetchfile_workflows_ci_badge_svg not found

Synopsis

Description

Installation

Support

Licence and Copyright

URI::FetchFile v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation