class CompUnit::Repository::FileSystem

CompUnit::Repository::FileSystem
class CompUnit::Repository::FileSystem
    does CompUnit::Repository::Locally
    does CompUnit::Repository
    { }

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

Methods

method candidates

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 $name, auth, ver, and 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";
    }

method files

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

Return all distributions that match the specified auth ver and api, and contains a non-module file matching the specified $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␤»

method resolve

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

Returns a CompUnit mapped to the highest version distribution matching $spec from the first repository in the repository chain that contains any version of a distribution matching $spec.

method need

method need(
    CompUnit::DependencySpecification $spec,
    CompUnit::PrecompilationRepository $precomp = self.precomp-repository(),
    CompUnit::PrecompilationStore :@precomp-stores = self!precomp-stores(),
    --> CompUnit:D)

Loads and returns a CompUnit which is mapped to the highest version distribution matching $spec from the first repository in the repository chain that contains any version of a distribution matching $spec.

method load

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

Load the $file and return a CompUnit object representing it.

method loaded

method loaded(--> Iterable:D)

Returns all CompUnits this repository has loaded.

method short-id

method short-id()

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

attribute extensions

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

    # Like '-I lib', but only considers .rakumod and .pm6 files as raku modules
    raku -I "file#extensions<rakumod pm6>#lib" -e 'use MyModule'

See Also

class Attribute

Member variable

class Cancellation

Removal of a task from a Scheduler before normal completion

class Channel

Thread-safe queue for sending values from producers to consumers

class CompUnit

CompUnit

class CompUnit::Repository::Installation

CompUnit::Repository::Installation

class Distro

Distribution related information

class Grammar

Formal grammar made up of named regexes

class IO::ArgFiles

Iterate over contents of files specified on command line

class IO::CatHandle

Use multiple IO handles as if they were one

class IO::Handle

Opened file or stream

class IO::Notification

Asynchronous notification for file and directory changes

class IO::Notification::Change

Changes in a file, produced by watch-file

class IO::Path

File or directory path

class IO::Path::Cygwin

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

class IO::Path::Parts

IO::Path parts encapsulation

class IO::Path::QNX

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

class IO::Path::Unix

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

class IO::Path::Win32

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

class IO::Pipe

Buffered inter-process string or binary stream

class IO::Socket::Async

Asynchronous socket in TCP or UDP

class IO::Socket::Async::ListenSocket

A tap for listening TCP sockets

class IO::Socket::INET

TCP Socket

class IO::Spec

Platform specific operations on file and directory paths

class IO::Spec::Cygwin

Platform specific operations on file and directory paths for Cygwin

class IO::Spec::QNX

Platform specific operations on file and directory paths QNX

class IO::Spec::Unix

Platform specific operations on file and directory paths for POSIX

class IO::Spec::Win32

Platform specific operations on file and directory paths for Windows

class IO::Special

Path to special I/O device

class Kernel

Kernel related information

class Lock

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

class Lock::ConditionVariable

Condition variables used in locks

class Match

Result of a successful regex match

class Pod::Block

Block in a Pod document

class Pod::Block::Code

Verbatim code block in a Pod document

class Pod::Block::Comment

Comment in a Pod document

class Pod::Block::Declarator

Declarator block in a Pod document

class Pod::Block::Named

Named block in a Pod document

class Pod::Block::Para

Paragraph in a Pod document

class Pod::Block::Table

Table in a Pod document

class Pod::Defn

Pod definition list

class Pod::FormattingCode

Pod formatting code

class Pod::Heading

Heading in a Pod document

class Pod::Item

Item in a Pod enumeration list

class Proc

Running process (filehandle-based interface)

class Proc::Async

Running process (asynchronous interface)

class Promise

Status/result of an asynchronous computation

class Regex

String pattern

class Semaphore

Control access to shared resources by multiple threads

class Supplier

Live Supply factory

class Supplier::Preserving

Cached live Supply factory

class Supply

Asynchronous data stream with multiple subscribers

class Tap

Subscription to a Supply

class Thread

Concurrent execution of code (low-level)

class ThreadPoolScheduler

Scheduler that distributes work among a pool of threads

class Unicode

Unicode related information

class VM

Raku Virtual Machine related information

The Camelia image is copyright 2009 by Larry Wall. "Raku" is trademark of the Yet Another Society. All rights reserved.