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

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::Encode

Synopsis

See also

Author

License

URI::Encode v0.09

Authors

License

Dependencies

Test Dependencies

Provides

Documentation