🔍 ⌘K/ctrl-K

class IO::Spec::Unix

Platform specific operations on file and directory paths for POSIX 
class IO::Spec::Unix is IO::Spec  { }

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 

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

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

method basename 

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

Takes a path as a string and returns a possibly-empty portion after the last slash: 

IO::Spec::Unix.basename("foo/bar/") .raku.say; # OUTPUT: «""␀»
    IO::Spec::Unix.basename("foo/bar/.").raku.say; # OUTPUT: «"."␀»
    IO::Spec::Unix.basename("foo/bar")  .raku.say; # OUTPUT: «"bar"␀»

method canonpath 

method canonpath(Str() $path, :$parent --> Str:D)

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. 

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␀»

method catdir 

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

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. 

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

method catfile

Alias for catdir.

method catpath 

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

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). 

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

method curdir 

method curdir()

Returns a string representing the current directory: 

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

method curupdir 

method curupdir()

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. 

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

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

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 version 2020.06 a none Junction was returned instead of a Block.

method devnull 

method devnull(--> Str:D)

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

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

method dir-sep 

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

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

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

method extension

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

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

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. 

$*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"␀»

method is-absolute 

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

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

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␀»

method join 

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

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). 

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␀»

method path 

method path(--> Seq:D)

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. 

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

method rel2abs 

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

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. 

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/../..␀»

method rootdir 

method rootdir(--> Str:D)

Returns string '/', representing root directory.

method split 

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

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

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("","","")␀»

Note: Before Rakudo version 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 

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

Splits the given $path on slashes. 

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: «("",)␀»

method splitpath 

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

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. 

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: «("", "", "")␀»

method tmpdir 

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

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 

method updir()

Returns a string representing the directory one up from current: 

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

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

CompUnit::Repository::FileSystem

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