Raku highlighting

class IO::Spec::Unix is IO::Spec  { }

Code

An object of this type is available via the variable $*SPEC if the Raku interpreter is running on a Unix-like platform.

About this class and its related classes also see IO::Spec.

Methods §

method abs2rel §

Raku highlighting

method abs2rel(IO::Path:D $path, IO::Path:D $base = $*CWD --> Str:D)

Code

Returns a string that represents $path, but relative to $base path. Both $path and $base may be relative paths. $base defaults to $*CWD.

Returns a string that is a canonical representation of $path. If :$parent is set to true, will also clean up references to parent directories. NOTE: the routine does not access the filesystem, so no symlinks are followed.

Raku highlighting

IO::Spec::Unix.canonpath("foo//../bar/../ber").say;
# OUTPUT: «foo/../bar/../ber␤»

IO::Spec::Unix.canonpath("foo///./../bar/../ber").say;
# OUTPUT: «foo/../bar/../ber␤»

IO::Spec::Unix.canonpath("foo///./../bar/../ber", :parent).say;
# OUTPUT: «ber␤»

Code

method catdir §

Raku highlighting

method catdir (*@parts --> Str:D)

Code

Concatenates multiple path fragments and returns the canonical representation of the resultant path as a string. The @parts are Str objects and are allowed to contain path separators.

Raku highlighting

IO::Spec::Unix.catdir(<foo/bar ber raku>).say; # OUTPUT: «foo/bar/ber/raku␤»

Code

method catfile §

Alias for catdir.

method catpath §

Raku highlighting

method catpath ($, Str:D $part1, Str:D $part2 --> Str:D)

Code

Takes two path fragments and concatenates them, adding or removing a path separator, if necessary. The first argument is ignored (it exists to maintain consistent interface with other IO::Spec types for systems that have volumes).

Raku highlighting

IO::Spec::Unix.catpath($, 'some/dir', 'and/more').say;
# OUTPUT: «some/dir/and/more␤»

Code

method curdir §

Raku highlighting

method curdir()

Code

Returns a string representing the current directory:

Raku highlighting

say '.' eq $*SPEC.curdir; # OUTPUT: «True␤»

Code

method curupdir §

Raku highlighting

method curupdir()

Code

Returns a Block taking an argument. This block returns True if its argument is neither the string representing the current directory nor the string representing the directory one up from the current one. It returns False otherwise. This block is intended to be used with smartmatching.

Raku highlighting

say $*SPEC.curupdir;
# OUTPUT: «-> str $dir { #`(Block|65335808) ... }␤»

my @dirs = <. foo .. bar>;
say @dirs.grep: { $_ ~~ $*SPEC.curupdir };
# OUTPUT: «(foo bar)␤»

Code

Neither foo nor bar are equal to the representation of the current or parent directory, that is why they are returned by grep.

Note: Before Rakudo release 2020.06 a none Junction was returned instead of a Block.

method devnull §

Raku highlighting

method devnull(--> Str:D)

Code

Returns the string "/dev/null" representing the "Null device":

Raku highlighting

$*SPEC.devnull.IO.spurt: "foo bar baz";

Code

method dir-sep §

Raku highlighting

method dir-sep(--> Str:D)

Code

Returns the string "/" representing canonical directory separator character.

Raku highlighting

IO::Spec::Unix.dir-sep.say; # OUTPUT: «/␤»

Code

method extension §

NOTE: Most users would want to use the higher-level routine IO::Path.extension instead of this lower-level version.

Raku highlighting

method extension(Str:D $path --> Str:D)

Code

Takes a string representing a base name and returns the characters after the last dot ("."), or empty string if no dots are present. The routine makes no attempt to detect path separators and will return everything after the last dot.

Raku highlighting

$*SPEC.extension('foo.'      ).raku.say;  # OUTPUT: «""␤»
$*SPEC.extension('foo.txt'   ).raku.say;  # OUTPUT: «"txt"␤»
$*SPEC.extension('foo.tar.gz').raku.say;  # OUTPUT: «"gz"␤»
$*SPEC.extension('foo'       ).raku.say;  # OUTPUT: «""␤»
$*SPEC.extension('bar.foo/foo').raku.say; # OUTPUT: «"foo/foo"␤»

Code

method is-absolute §

Raku highlighting

method is-absolute(Str:D $path --> Bool:D)

Code

Returns True if the $path starts with a slash ("/"), even if it has combining character on it:

Raku highlighting

say IO::Spec::Unix.is-absolute: "/foo";        # OUTPUT: «True␤»
say IO::Spec::Unix.is-absolute: "/\x[308]foo"; # OUTPUT: «True␤»
say IO::Spec::Unix.is-absolute: "bar";         # OUTPUT: «False␤»

Code

method join §

Raku highlighting

method join ($, Str:D $dir, Str:D $file --> Str:D)

Code

Similar to catpath, takes two path fragments and concatenates them, adding or removing a path separator, if necessary, except it will return just $file if both $dir and $file are string '/' or if $dir is the string '.'. The first argument is ignored (it exists to maintain consistent interface with other IO::Spec types for systems that have volumes).

Raku highlighting

IO::Spec::Unix.join($, 'foo', 'bar').say; # OUTPUT: «foo/bar␤»
IO::Spec::Unix.join($, '/', '/').say;     # OUTPUT: «/␤»
IO::Spec::Unix.join($, '.', 'foo').say;   # OUTPUT: «foo␤»
say $*SPEC.join(True,".","/foo");         # OUTPUT: «/foo␤»

Code

method path §

Raku highlighting

method path(--> Seq:D)

Code

Splits the value of %*ENV<PATH> on colons (":"), replaces empty parts with ".", and returns a Seq with each of the resultant parts. Returns an empty Seq if %*ENV<PATH> is not set or is an empty string.

Raku highlighting

%*ENV<PATH> = 'foo:bar/ber::foo:';
IO::Spec::Unix.path.raku.say;
# OUTPUT: «("foo", "bar/ber", ".", "foo", ".").Seq␤»

Code

method rel2abs §

Raku highlighting

method rel2abs(Str() $path, $base = $*CWD --> Str:D)

Code

Returns a string representing $path converted to absolute path, based at $base, which defaults to $*CWD. If $base is not an absolute path, it will be made absolute relative to $*CWD, unless $*CWD and $base are the same.

Raku highlighting

say $*CWD;                                  # OUTPUT: «"/home/camelia".IO␤»

say IO::Spec::Unix.rel2abs: 'foo';          # OUTPUT: «/home/camelia/foo␤»
say IO::Spec::Unix.rel2abs: './';           # OUTPUT: «/home/camelia␤»
say IO::Spec::Unix.rel2abs: 'foo/../../';   # OUTPUT: «/home/camelia/foo/../..␤»
say IO::Spec::Unix.rel2abs: '/foo/';        # OUTPUT: «/foo␤»

say IO::Spec::Unix.rel2abs: 'foo', 'bar';   # OUTPUT: «/home/camelia/bar/foo␤»
say IO::Spec::Unix.rel2abs: './', '/bar';   # OUTPUT: «/bar␤»
say IO::Spec::Unix.rel2abs: '/foo/', 'bar'; # OUTPUT: «/foo␤»

say IO::Spec::Unix.rel2abs: 'foo/../../', 'bar';
# OUTPUT: «/home/camelia/bar/foo/../..␤»

Code

method rootdir §

Raku highlighting

method rootdir(--> Str:D)

Code

Returns string '/', representing root directory.

method split §

Raku highlighting

method split(IO::Spec::Unix: Cool:D $path)

Code

Creates an IO::Path::Parts for $path, with an empty string as its volume attribute's value.

Raku highlighting

IO::Spec::Unix.split('C:/foo/bar.txt').raku.say;
# OUTPUT: «IO::Path::Parts.new("","C:/foo","bar.txt")␤»

IO::Spec::Unix.split('/foo/').raku.say;
# OUTPUT: «IO::Path::Parts.new("","/","foo")␤»

IO::Spec::Unix.split('///').raku.say;
# OUTPUT: «IO::Path::Parts.new("","/","/")␤»

IO::Spec::Unix.split('./').raku.say;
# OUTPUT: «IO::Path::Parts.new("",".",".")␤»

IO::Spec::Unix.split('.').raku.say;
# OUTPUT: «IO::Path::Parts.new("",".",".")␤»

IO::Spec::Unix.split('').raku.say;
# OUTPUT: «IO::Path::Parts.new("","","")␤»

Code

Note: Before Rakudo release 2020.06 this method split the given $path into "volume", "dirname", and "basename" and returned the result as a List of three Pairs, in that order.

method splitdir §

Raku highlighting

method splitdir(Cool:D $path --> List:D)

Code

Splits the given $path on slashes.

Raku highlighting

IO::Spec::Unix.splitdir('C:\foo/bar.txt').raku.say;
# OUTPUT: «("C:\\foo", "bar.txt")␤»

IO::Spec::Unix.splitdir('/foo/').raku.say;
# OUTPUT: «("", "foo", "")␤»

IO::Spec::Unix.splitdir('///').raku.say;
# OUTPUT: «("", "", "", "")␤»

IO::Spec::Unix.splitdir('./').raku.say;
# OUTPUT: «(".", "")␤»

IO::Spec::Unix.splitdir('.').raku.say;
# OUTPUT: «(".",)␤»

IO::Spec::Unix.splitdir('').raku.say;
# OUTPUT: «("",)␤»

Code

method splitpath §

Raku highlighting

method splitpath(Cool:D $path, :$nofile --> List:D)

Code

Splits the given $path into a list of 3 strings: volume, dirname, and file. The volume is always an empty string, returned for API compatibility with other IO::Spec types. If :$nofile named argument is set to True, the content of the file string is undefined and should be ignored; this is a means to get a performance boost, as implementations may use faster code path when file is not needed.

Raku highlighting

IO::Spec::Unix.splitpath('C:\foo/bar.txt').raku.say;
# OUTPUT: «("", "C:\\foo/", "bar.txt")␤»

IO::Spec::Unix.splitpath('C:\foo/bar.txt', :nofile).raku.say;
# OUTPUT: «("", "C:\\foo/bar.txt", "")␤»

IO::Spec::Unix.splitpath('/foo/').raku.say;
# OUTPUT: «("", "/foo/", "")␤»

IO::Spec::Unix.splitpath('/foo/', :nofile).raku.say;
# OUTPUT: «("", "/foo/", "")␤»

IO::Spec::Unix.splitpath('///').raku.say;
# OUTPUT: «("", "///", "")␤»

IO::Spec::Unix.splitpath('./').raku.say;
# OUTPUT: «("", "./", "")␤»

IO::Spec::Unix.splitpath('.').raku.say;
# OUTPUT: «("", "", ".")␤»

IO::Spec::Unix.splitpath('').raku.say;
# OUTPUT: «("", "", "")␤»

Code

method tmpdir §

Raku highlighting

method tmpdir(--> IO::Path:D)

Code

Attempts to locate a system's temporary directory by checking several typical directories and environment variables. Uses current directory if no suitable directories are found.

method updir §

Raku highlighting

method updir()

Code

Returns a string representing the directory one up from current:

Raku highlighting

say '..' eq $*SPEC.updir; # OUTPUT: «True␤»

Code

class IO::Spec::Unix

Methods §

method abs2rel §

method basename §

method canonpath §

method catdir §

method catfile §

method catpath §

method curdir §

method curupdir §

method devnull §

method dir-sep §

method extension §

method is-absolute §

method join §

method path §

method rel2abs §

method rootdir §

method split §

method splitdir §

method splitpath §

method tmpdir §

method updir §