TITLE

SUBTITLE

The C<CompUnit::Repository> role defines the interface of the implementation
of CompUnit::Repositories such as L<C<CompUnit::Repository::Installation>|/type/CompUnit::Repository::Installation>
and L<C<CompUnit::Repository::FileSystem>|/type/CompUnit::Repository::FileSystem>.


head

method resolve(CompUnit::DependencySpecification $spec --> CompUnit:D)


Returns a L<C<CompUnit>|/type/CompUnit> mapped to the highest version distribution matching
C<$spec> from the first repository in the repository chain that contains any
version of a distribution matching C<$spec>.


Loads and returns a L<C<CompUnit>|/type/CompUnit> which is mapped to the highest version
distribution matching C<$spec> from the first repository in the repository
chain that contains any version of a distribution matching C<$spec>.


method load(IO::Path:D $file --> CompUnit:D)


Load the C<$file> and return a L<C<CompUnit>|/type/CompUnit> object representing it.


Returns all L<C<CompUnit>|/type/CompUnit>s this repository has loaded.


root

CompUnit::PrecompilationRepository


role CompUnit::PrecompilationRepository


Input/output related routines


role IO


Network socket


role IO::Socket


Scheme for automatically assigning tasks to threads


role Scheduler


Information related to the build system


role Systemic


CompUnit::Repository


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

role CompUnit::Repository


code

A L<C<CompUnit::Repository>|/type/CompUnit::Repository> implementation backed by the filesystem typically used
in development situations. This is what is used by C<-I .> / C<-I lib> (which are
actually C<-I file#.> and C<-I file#lib>) or C<use lib "."> / C<use lib "lib">.
Unlike L<C<CompUnit::Repository::Installation>|/type/CompUnit::Repository::Installation>, this represents a single distribution.


multi method candidates(Str:D $name, :$auth, :$ver, :$api)
multi method candidates(CompUnit::DependencySpecification $spec)


Return all distributions that contain a module matching the specified C<$name>, C<auth>,
C<ver>, and C<api>.


# assuming one is cloned into the zef git repository...
my $repo = CompUnit::Repository::FileSystem.new(prefix => $*CWD);
with $repo.candidates("Zef").head -> $dist {
    say "Zef version: " ~ $dist.meta<version>;
}
else {
    say "No candidates for 'Zef' found";
}


multi method files(Str:D $name, :$auth, :$ver, :$api)
multi method files(CompUnit::DependencySpecification $spec)


Return all distributions that match the specified C<auth> C<ver> and C<api>, and
contains a non-module file matching the specified C<$name>.


# assuming one is cloned into the zef git repository...
my $repo = CompUnit::Repository::FileSystem.new(prefix => $*CWD);
say $repo.files('bin/zef', :ver<419.0+>).head.<name>              // "Nada"; # OUTPUT: «Nada␤»
say $repo.files('resources/config.txt', :ver<419.0+>).head.<name> // "Nada"; # OUTPUT: «Nada␤»


say $repo.files('bin/zef', :ver<0.4.0+>).head.<name>;                        # OUTPUT: «zef␤»
say $repo.files('resources/config.txt', :ver<0.4.0+>).head.<name>;           # OUTPUT: «zef␤»


Returns a L<C<CompUnit>|/type/CompUnit> mapped to the highest version distribution matching C<$spec> from
the first repository in the repository chain that contains any version of a distribution
matching C<$spec>.


Loads and returns a L<C<CompUnit>|/type/CompUnit> which is mapped to the highest version distribution
matching C<$spec> from the first repository in the repository chain that contains
any version of a distribution matching C<$spec>.


Returns the repo short-id, which for this repository is C<file>.


my $repo = CompUnit::RepositoryFileSystem.new(:prefix($*CWD));
say $repo.extensions; # OUTPUT: «[rakumod pm6 pm]␤»


The extensions of files the repository will consider raku modules when C<prefix> does
not contain a META6.json file. This can be set when including the library path itself
by setting the attribute through the path spec:


Member variable


class Attribute


Removal of a task from a Scheduler before normal completion


class Cancellation


Thread-safe queue for sending values from producers to consumers


class Channel


CompUnit


class CompUnit


CompUnit::Repository::Installation


class CompUnit::Repository::Installation


Distribution related information


class Distro


Formal grammar made up of named regexes


class Grammar


Iterate over contents of files specified on command line


class IO::ArgFiles


Use multiple IO handles as if they were one


class IO::CatHandle


Opened file or stream


class IO::Handle


Asynchronous notification for file and directory changes





class IO::Notification


Changes in a file, produced by watch-file


class IO::Notification::Change


File or directory path


class IO::Path


IO::Path pre-loaded with IO::Spec::Cygwin


class IO::Path::Cygwin


IO::Path parts encapsulation


class IO::Path::Parts


IO::Path pre-loaded with IO::Spec::QNX


class IO::Path::QNX


IO::Path pre-loaded with IO::Spec::Unix


class IO::Path::Unix


IO::Path pre-loaded with IO::Spec::Win32


class IO::Path::Win32


Buffered inter-process string or binary stream


class IO::Pipe


Asynchronous socket in TCP or UDP


class IO::Socket::Async


A tap for listening TCP sockets


class IO::Socket::Async::ListenSocket


TCP Socket


class IO::Socket::INET


Platform specific operations on file and directory paths


class IO::Spec


Platform specific operations on file and directory paths for Cygwin


class IO::Spec::Cygwin


Platform specific operations on file and directory paths QNX


class IO::Spec::QNX


Platform specific operations on file and directory paths for POSIX


class IO::Spec::Unix


Platform specific operations on file and directory paths for Windows


class IO::Spec::Win32


Path to special I/O device


class IO::Special


Kernel related information


class Kernel


A low-level, re-entrant, mutual exclusion lock


class Lock


Condition variables used in locks


class Lock::ConditionVariable


Result of a successful regex match


class Match


Block in a Pod document


class Pod::Block


Verbatim code block in a Pod document


class Pod::Block::Code


Comment in a Pod document


class Pod::Block::Comment


Declarator block in a Pod document


class Pod::Block::Declarator


Named block in a Pod document


class Pod::Block::Named


Paragraph in a Pod document


class Pod::Block::Para


Table in a Pod document


class Pod::Block::Table


Pod definition list


class Pod::Defn


Pod formatting code


class Pod::FormattingCode


Heading in a Pod document


class Pod::Heading


Item in a Pod enumeration list


class Pod::Item


Running process (filehandle-based interface)


class Proc


Running process (asynchronous interface)


class Proc::Async


Status/result of an asynchronous computation


class Promise


String pattern


class Regex


Control access to shared resources by multiple threads


class Semaphore


Live Supply factory


class Supplier


Cached live Supply factory


class Supplier::Preserving


Asynchronous data stream with multiple subscribers


class Supply


Subscription to a Supply


class Tap


Concurrent execution of code (low-level)


class Thread


Scheduler that distributes work among a pool of threads


class ThreadPoolScheduler


Unicode related information


class Unicode


Raku Virtual Machine related information


class VM


CompUnit::Repository::FileSystem


class CompUnit::Repository::FileSystem


This class provides stubs for each of the following methods. The methods are provided by sub-classes,
such as C<PrecompilationRepository::File>. Sub-classes are implementation dependent.


method new-unit(| --> CompUnit::PrecompilationUnit:D)
{ ... }


Prepare a new implementation specific PrecompilationUnit for storage


method load-unit(CompUnit::PrecompilationId $compiler-id,
            CompUnit::PrecompilationId $precomp-id)
{ ... }


Load the precompilation identified by the pairing of the specified
compiler and precompilation ID.


method load-repo-id(CompUnit::PrecompilationId $compiler-id,
            CompUnit::PrecompilationId $precomp-id)
{ ... }


Return the repository id for which the specified precomp file's
dependencies have been validated


method store-file(CompUnit::PrecompilationId $compiler-id,
             CompUnit::PrecompilationId $precomp-id,
             IO::Path:D $path,
             :$extension = '')
{ ... }


Store the file at the specified path in the precompilation store,
under the given compiler ID and precompilation ID.


method store-unit(CompUnit::PrecompilationId $compiler-id,
             CompUnit::PrecompilationId $precomp-id,
             CompUnit::PrecompilationUnit $unit)
{ ... }


Store the given precompilation unit in the precompilation store
under the given compiler ID and precompilation ID.


method store-repo-id(CompUnit::PrecompilationId $compiler-id,
             CompUnit::PrecompilationId $precomp-id,
             :$repo-id!)
{ ... }


Store the given repo-id for a precompilation under the given
compiler ID and precompilation ID.


method delete(CompUnit::PrecompilationId $compiler-id,
              CompUnit::PrecompilationId $precomp-id)
{ ... }


method delete-by-compiler(CompUnit::PrecompilationId $compiler-id)
{ ... }


Delete all precompilations for a particular compiler.


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


role CompUnit::Repository

Methods

method resolve

method need

method load

method loaded

See Also