class IO::Spec::Win32

Platform specific operations on file and directory paths for Windows

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

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

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

Methods§

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

IO::Spec::Win32.basename("foo/bar/") .raku.say; # OUTPUT: «""␤» 
IO::Spec::Win32.basename("foo/bar\\").raku.say; # OUTPUT: «""␤» 
IO::Spec::Win32.basename("foo/bar/.").raku.say; # OUTPUT: «"."␤» 
IO::Spec::Win32.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.

IO::Spec::Win32.canonpath("C:/foo//../bar/../ber").say;
# OUTPUT: «C:\foo\..\bar\..\ber␤» 
 
IO::Spec::Win32.canonpath("C:/foo///./../bar/../ber").say;
# OUTPUT: «C:\foo\..\bar\..\ber␤» 
 
IO::Spec::Win32.canonpath("C:/foo///./../bar/../ber", :parent).say;
# OUTPUT: «C:\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::Win32.catdir(<foo/bar ber raku>).say;
# OUTPUT: «foo\bar\ber\raku␤»

method catfile§

Alias for catdir.

method catpath§

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

Concatenates a path from given volume, a chain of directories, and file. An empty string can be given for any of the three arguments. No attempt to make the path canonical is made. Use canonpath for that purpose.

IO::Spec::Win32.catpath('C:', '/some/dir', 'foo.txt').say;
# OUTPUT: «C:/some/dir\foo.txt␤» 
 
IO::Spec::Win32.catpath('C:', '/some/dir', '').say;
# OUTPUT: «C:/some/dir␤» 
 
IO::Spec::Win32.catpath('', '/some/dir', 'foo.txt').say;
# OUTPUT: «/some/dir\foo.txt␤» 
 
IO::Spec::Win32.catpath('E:', '', 'foo.txt').say;
# OUTPUT: «E:foo.txt␤»

method devnull§

method devnull(--> Str:D)

Returns the string "nul" 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::Win32.dir-sep.say; # OUTPUT: «\␤» 

method is-absolute§

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

Returns True if the $path starts with a slash ("/") or backslash ("\"), even if they have combining character on them, optionally preceded by a volume:

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

method join§

method join (Str:D $volume, 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::Win32.join('C:', '/some/dir', 'foo.txt').say;
# OUTPUT: «C:/some/dir\and/more␤» 
 
IO::Spec::Win32.join('C:', '.', 'foo.txt').say;
# OUTPUT: «C:foo.txt␤» 
 
IO::Spec::Win32.join('C:', ｢\｣, '/').say;
# OUTPUT: «C:\␤» 
 
IO::Spec::Win32.join('//server/share', ｢\｣, '/').say;
# OUTPUT: «//server/share␤» 
 
IO::Spec::Win32.join('E:', '', 'foo.txt').say;
# OUTPUT: «E:foo.txt␤»

method path§

method path(--> Seq:D)

Splits the value of %*ENV<PATH> (or %*ENV<Path> if the former is not set) on semicolons (";") and returns a Seq with each of the resultant parts, always adding element "." to the head. Removes all double quotes (") it finds.

%*ENV<PATH> = 'foo;"bar"/"ber"';
IO::Spec::Win32.path.raku.say; # OUTPUT: «(".", "foo", "bar/ber").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: «"C:\Users\camelia".IO␤» 
 
say IO::Spec::Win32.rel2abs: 'foo';          # OUTPUT: «C:\Users\camelia\foo␤» 
say IO::Spec::Win32.rel2abs: './';           # OUTPUT: «C:\Users\camelia␤» 
say IO::Spec::Win32.rel2abs: 'foo/../../';   # OUTPUT: «C:\Users\camelia\foo\..\..␤» 
say IO::Spec::Win32.rel2abs: '/foo/';        # OUTPUT: «C:\foo␤» 
 
say IO::Spec::Win32.rel2abs: 'foo', 'bar';   # OUTPUT: «C:\Users\camelia\bar\foo␤» 
say IO::Spec::Win32.rel2abs: './', '/bar';   # OUTPUT: «\bar␤» 
say IO::Spec::Win32.rel2abs: '/foo/', 'bar'; # OUTPUT: «C:\foo␤» 
 
say IO::Spec::Win32.rel2abs: 'foo/../../', 'bar';
# OUTPUT: «C:\Users\camelia\bar\foo\..\..␤» 

method rootdir§

method rootdir(--> Str:D)

Returns string ｢\｣, representing root directory.

method split§

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

Creates a IO::Path::Parts for $path.

IO::Spec::Win32.split('C:/foo/bar.txt').raku.say;
# OUTPUT: «IO::Path::Parts.new("C:","/foo","bar.txt")␤» 
 
IO::Spec::Win32.split('/foo/').raku.say;
# OUTPUT: «IO::Path::Parts.new("","/","foo")␤» 
 
IO::Spec::Win32.split('///').raku.say;
# OUTPUT: «IO::Path::Parts.new("","/","\\")␤» 
 
IO::Spec::Win32.split('./').raku.say;
# OUTPUT: «IO::Path::Parts.new("",".",".")␤» 
 
IO::Spec::Win32.split('.').raku.say;
# OUTPUT: «IO::Path::Parts.new("",".",".")␤» 
 
IO::Spec::Win32.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 and backslashes.

IO::Spec::Win32.splitdir('C:\foo/bar.txt').raku.say;
# OUTPUT: «("C:", "foo", "bar.txt")␤» 
 
IO::Spec::Win32.splitdir('/foo/').raku.say;
# OUTPUT: «("", "foo", "")␤» 
 
IO::Spec::Win32.splitdir('///').raku.say;
# OUTPUT: «("", "", "", "")␤» 
 
IO::Spec::Win32.splitdir('./').raku.say;
# OUTPUT: «(".", "")␤» 
 
IO::Spec::Win32.splitdir('.').raku.say;
# OUTPUT: «(".",)␤» 
 
IO::Spec::Win32.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::Win32.splitpath('C:\foo/bar.txt').raku.say;
# OUTPUT: «("C:", "\\foo/", "bar.txt")␤» 
 
IO::Spec::Win32.splitpath('C:\foo/bar.txt', :nofile).raku.say;
# OUTPUT: «("C:", "\\foo/bar.txt", "")␤» 
 
IO::Spec::Win32.splitpath('/foo/').raku.say;
# OUTPUT: «("", "/foo/", "")␤» 
 
IO::Spec::Win32.splitpath('/foo/', :nofile).raku.say;
# OUTPUT: «("", "/foo/", "")␤» 
 
IO::Spec::Win32.splitpath('///').raku.say;
# OUTPUT: «("", "///", "")␤» 
 
IO::Spec::Win32.splitpath('./').raku.say;
# OUTPUT: «("", "./", "")␤» 
 
IO::Spec::Win32.splitpath('.').raku.say;
# OUTPUT: «("", "", ".")␤» 
 
IO::Spec::Win32.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.