From 9fd5fdf0e56189c79f37fdd534f048d290dfce34 Mon Sep 17 00:00:00 2001 From: Mathias Lang Date: Fri, 19 Jan 2024 20:29:48 +0100 Subject: [PATCH] Update path module to vibe-core@2.7.3 --- dub.sdl | 2 + source/dub/internal/vibecompat/inet/path.d | 1945 ++++++++++++++++---- source/dub/internal/vibecompat/inet/url.d | 9 - source/dub/packagesuppliers/filesystem.d | 2 + 4 files changed, 1614 insertions(+), 344 deletions(-) diff --git a/dub.sdl b/dub.sdl index 642a20482..0b5d93443 100644 --- a/dub.sdl +++ b/dub.sdl @@ -31,12 +31,14 @@ configuration "library" { } configuration "library-nonet" { + dependency "vibe-core" version="~>2" optional=true dependency "vibe-d:http" version=">=0.9.0 <0.10.0" optional=true targetType "library" excludedSourceFiles "source/app.d" } configuration "dynamic-library-nonet" { + dependency "vibe-core" version="~>2" optional=true dependency "vibe-d:http" version=">=0.9.0 <0.10.0" optional=true targetType "dynamicLibrary" excludedSourceFiles "source/app.d" diff --git a/source/dub/internal/vibecompat/inet/path.d b/source/dub/internal/vibecompat/inet/path.d index 745ebc017..8179563d4 100644 --- a/source/dub/internal/vibecompat/inet/path.d +++ b/source/dub/internal/vibecompat/inet/path.d @@ -1,7 +1,7 @@ /** Contains routines for high level path handling. - Copyright: © 2012 rejectedsoftware e.K. + Copyright: © 2012-2021 Sönke Ludwig License: Subject to the terms of the MIT license, as written in the included LICENSE.txt file. Authors: Sönke Ludwig */ @@ -10,361 +10,906 @@ module dub.internal.vibecompat.inet.path; version (Have_vibe_core) public import vibe.core.path; else: -import std.algorithm; -import std.array; -import std.conv; -import std.exception; -import std.string; +import std.algorithm.searching : commonPrefix, endsWith, startsWith; +import std.algorithm.comparison : equal, min; +import std.algorithm.iteration : map; +import std.exception : enforce; +import std.range : empty, front, popFront, popFrontExactly, takeExactly; +import std.range.primitives : ElementType, isInputRange, isOutputRange, isForwardRange, save; +import std.traits : isArray, isInstanceOf, isSomeChar; +import std.utf : byChar; -deprecated("Use NativePath instead.") -alias Path = NativePath; +/** Computes the relative path from `base_path` to this path. -/** - Represents an absolute or relative file system path. + Params: + path = The destination path + base_path = The path from which the relative path starts - This struct allows to do safe operations on paths, such as concatenation and sub paths. Checks - are done to disallow invalid operations such as concatenating two absolute paths. It also - validates path strings and allows for easy checking of malicious relative paths. + See_also: `relativeToWeb` */ -struct NativePath { - private { - immutable(PathEntry)[] m_nodes; - bool m_absolute = false; - bool m_endsWithSlash = false; +Path relativeTo(Path)(Path path, Path base_path) @safe + if (isInstanceOf!(GenericPath, Path)) +{ + import std.array : array, replicate; + import std.range : chain, drop, take; + + assert(base_path.absolute, "Base path must be absolute for relativeTo."); + assert(path.absolute, "Path must be absolute for relativeTo."); + + if (is(Path == WindowsPath)) { // FIXME: this shouldn't be a special case here! + bool samePrefix(size_t n) + { + return path.bySegment.map!(n => n.encodedName).take(n).equal(base_path.bySegment.map!(n => n.encodedName).take(n)); + } + // a path such as ..\C:\windows is not valid, so force the path to stay absolute in this case + auto pref = path.bySegment; + if (!pref.empty && pref.front.encodedName == "") { + pref.popFront(); + if (!pref.empty) { + // different drive? + if (pref.front.encodedName.endsWith(':') && !samePrefix(2)) + return path; + // different UNC path? + if (pref.front.encodedName == "" && !samePrefix(4)) + return path; + } + } } - alias Segment = PathEntry; + auto nodes = path.bySegment; + auto base_nodes = base_path.bySegment; - alias bySegment = nodes; + // skip and count common prefix + size_t base = 0; + while (!nodes.empty && !base_nodes.empty && equal(nodes.front.name, base_nodes.front.name)) { + nodes.popFront(); + base_nodes.popFront(); + base++; + } - /// Constructs a NativePath object by parsing a path string. - this(string pathstr) - { - m_nodes = splitPath(pathstr); - m_absolute = (pathstr.startsWith("/") || m_nodes.length > 0 && (m_nodes[0].toString().countUntil(':')>0 || m_nodes[0] == "\\")); - m_endsWithSlash = pathstr.endsWith("/"); + enum up = Path.Segment2("..", Path.defaultSeparator); + auto ret = Path(base_nodes.map!(p => up).chain(nodes)); + if (path.endsWithSlash) { + if (ret.empty) return Path.fromTrustedString("." ~ path.toString()[$-1]); + else ret.endsWithSlash = true; } + return ret; +} + +/// +unittest { + import std.array : array; + import std.conv : to; + assert(PosixPath("/some/path").relativeTo(PosixPath("/")) == PosixPath("some/path")); + assert(PosixPath("/some/path/").relativeTo(PosixPath("/some/other/path/")) == PosixPath("../../path/")); + assert(PosixPath("/some/path/").relativeTo(PosixPath("/some/other/path")) == PosixPath("../../path/")); + + assert(WindowsPath("C:\\some\\path").relativeTo(WindowsPath("C:\\")) == WindowsPath("some\\path")); + assert(WindowsPath("C:\\some\\path\\").relativeTo(WindowsPath("C:\\some\\other\\path/")) == WindowsPath("..\\..\\path\\")); + assert(WindowsPath("C:\\some\\path\\").relativeTo(WindowsPath("C:\\some\\other\\path")) == WindowsPath("..\\..\\path\\")); + + assert(WindowsPath("\\\\server\\share\\some\\path").relativeTo(WindowsPath("\\\\server\\share\\")) == WindowsPath("some\\path")); + assert(WindowsPath("\\\\server\\share\\some\\path\\").relativeTo(WindowsPath("\\\\server\\share\\some\\other\\path/")) == WindowsPath("..\\..\\path\\")); + assert(WindowsPath("\\\\server\\share\\some\\path\\").relativeTo(WindowsPath("\\\\server\\share\\some\\other\\path")) == WindowsPath("..\\..\\path\\")); + + assert(WindowsPath("C:\\some\\path").relativeTo(WindowsPath("D:\\")) == WindowsPath("C:\\some\\path")); + assert(WindowsPath("C:\\some\\path\\").relativeTo(WindowsPath("\\\\server\\share")) == WindowsPath("C:\\some\\path\\")); + assert(WindowsPath("\\\\server\\some\\path\\").relativeTo(WindowsPath("C:\\some\\other\\path")) == WindowsPath("\\\\server\\some\\path\\")); + assert(WindowsPath("\\\\server\\some\\path\\").relativeTo(WindowsPath("\\\\otherserver\\path")) == WindowsPath("\\\\server\\some\\path\\")); + assert(WindowsPath("\\some\\path\\").relativeTo(WindowsPath("\\other\\path")) == WindowsPath("..\\..\\some\\path\\")); + + assert(WindowsPath("\\\\server\\share\\path1").relativeTo(WindowsPath("\\\\server\\share\\path2")) == WindowsPath("..\\path1")); + assert(WindowsPath("\\\\server\\share\\path1").relativeTo(WindowsPath("\\\\server\\share2\\path2")) == WindowsPath("\\\\server\\share\\path1")); + assert(WindowsPath("\\\\server\\share\\path1").relativeTo(WindowsPath("\\\\server2\\share2\\path2")) == WindowsPath("\\\\server\\share\\path1")); +} - /// Constructs a path object from a list of PathEntry objects. - this(immutable(PathEntry)[] nodes, bool absolute) +unittest { { - m_nodes = nodes; - m_absolute = absolute; + auto parentpath = "/path/to/parent"; + auto parentpathp = PosixPath(parentpath); + auto subpath = "/path/to/parent/sub/"; + auto subpathp = PosixPath(subpath); + auto subpath_rel = "sub/"; + assert(subpathp.relativeTo(parentpathp).toString() == subpath_rel); + auto subfile = "/path/to/parent/child"; + auto subfilep = PosixPath(subfile); + auto subfile_rel = "child"; + assert(subfilep.relativeTo(parentpathp).toString() == subfile_rel); } - /// Constructs a relative path with one path entry. - this(PathEntry entry){ - m_nodes = [entry]; - m_absolute = false; + { // relative paths across Windows devices are not allowed + auto p1 = WindowsPath("\\\\server\\share"); assert(p1.absolute); + auto p2 = WindowsPath("\\\\server\\othershare"); assert(p2.absolute); + auto p3 = WindowsPath("\\\\otherserver\\share"); assert(p3.absolute); + auto p4 = WindowsPath("C:\\somepath"); assert(p4.absolute); + auto p5 = WindowsPath("C:\\someotherpath"); assert(p5.absolute); + auto p6 = WindowsPath("D:\\somepath"); assert(p6.absolute); + auto p7 = WindowsPath("\\\\server\\share\\path"); assert(p7.absolute); + auto p8 = WindowsPath("\\\\server\\share\\otherpath"); assert(p8.absolute); + assert(p4.relativeTo(p5) == WindowsPath("..\\somepath")); + assert(p4.relativeTo(p6) == WindowsPath("C:\\somepath")); + assert(p4.relativeTo(p1) == WindowsPath("C:\\somepath")); + assert(p1.relativeTo(p2) == WindowsPath("\\\\server\\share")); + assert(p1.relativeTo(p3) == WindowsPath("\\\\server\\share")); + assert(p1.relativeTo(p4) == WindowsPath("\\\\server\\share")); + assert(p7.relativeTo(p1) == WindowsPath("path")); + assert(p7.relativeTo(p8) == WindowsPath("..\\path")); } - /// Determines if the path is absolute. - @property bool absolute() const scope @safe pure nothrow @nogc { return m_absolute; } + { // relative path, trailing slash + auto p1 = PosixPath("/some/path"); + auto p2 = PosixPath("/some/path/"); + assert(p1.relativeTo(p1).toString() == ""); + assert(p1.relativeTo(p2).toString() == ""); + assert(p2.relativeTo(p2).toString() == "./"); + } +} - /// Resolves all '.' and '..' path entries as far as possible. - void normalize() - { - immutable(PathEntry)[] newnodes; - foreach( n; m_nodes ){ - switch(n.toString()){ - default: - newnodes ~= n; - break; - case "", ".": break; - case "..": - enforce(!m_absolute || newnodes.length > 0, "Path goes below root node."); - if( newnodes.length > 0 && newnodes[$-1] != ".." ) newnodes = newnodes[0 .. $-1]; - else newnodes ~= n; - break; - } - } - m_nodes = newnodes; +nothrow unittest { + auto p1 = PosixPath.fromTrustedString("/foo/bar/baz"); + auto p2 = PosixPath.fromTrustedString("/foo/baz/bam"); + assert(p2.relativeTo(p1).toString == "../../baz/bam"); +} + + +/** Computes the relative path to this path from `base_path` using web path rules. + + The difference to `relativeTo` is that a path not ending in a slash + will not be considered as a path to a directory and the parent path + will instead be used. + + Params: + path = The destination path + base_path = The path from which the relative path starts + + See_also: `relativeTo` +*/ +Path relativeToWeb(Path)(Path path, Path base_path) @safe + if (isInstanceOf!(GenericPath, Path)) +{ + if (!base_path.endsWithSlash) { + assert(base_path.absolute, "Base path must be absolute for relativeToWeb."); + if (base_path.hasParentPath) base_path = base_path.parentPath; + else base_path = Path("/"); + assert(base_path.absolute); } + return path.relativeTo(base_path); +} - /// Converts the Path back to a string representation using slashes. - string toString() - const @safe { - if( m_nodes.empty ) return absolute ? "/" : ""; +/// +/+unittest { + assert(InetPath("/some/path").relativeToWeb(InetPath("/")) == InetPath("some/path")); + assert(InetPath("/some/path/").relativeToWeb(InetPath("/some/other/path/")) == InetPath("../../path/")); + assert(InetPath("/some/path/").relativeToWeb(InetPath("/some/other/path")) == InetPath("../path/")); +}+/ - Appender!string ret; - // for absolute paths start with / - version(Windows) - { - // Make sure windows path isn't "DRIVE:" - if( absolute && !m_nodes[0].toString().endsWith(':') ) - ret.put('/'); +/** Converts a path to its system native string representation. +*/ +string toNativeString(P)(P path) +{ + return (cast(NativePath)path).toString(); +} + + +/// Represents a path on Windows operating systems. +alias WindowsPath = GenericPath!WindowsPathFormat; + +/// Represents a path on Unix/Posix systems. +alias PosixPath = GenericPath!PosixPathFormat; + +/// Represents a path as part of an URI. +alias InetPath = GenericPath!InetPathFormat; + +/// The path type native to the target operating system. +version (Windows) alias NativePath = WindowsPath; +else alias NativePath = PosixPath; + +/// Provides a common interface to operate on paths of various kinds. +struct GenericPath(F) { +@safe: + alias Format = F; + + /// vibe-core 1.x compatibility alias + alias Segment2 = Segment; + + /** A single path segment. + */ + static struct Segment { + @safe: + + private { + string m_encodedName; + char m_separator = 0; } - else + + /** Constructs a new path segment including an optional trailing + separator. + + Params: + name = The raw (unencoded) name of the path segment + separator = Optional trailing path separator (e.g. `'/'`) + + Throws: + A `PathValidationException` is thrown if the name contains + characters that are invalid for the path type. In particular, + any path separator characters may not be part of the name. + */ + this(string name, char separator = '\0') { - if( absolute ) - { - ret.put('/'); + import std.algorithm.searching : any; + + enforce!PathValidationException(separator == '\0' || Format.isSeparator(separator), + "Invalid path separator."); + auto err = Format.validateDecodedSegment(name); + enforce!PathValidationException(err is null, err); + + m_encodedName = Format.encodeSegment(name); + m_separator = separator; + } + + /** Constructs a path segment without performing validation. + + Note that in debug builds, there are still assertions in place + that verify that the provided values are valid. + + Params: + name = The raw (unencoded) name of the path segment + separator = Optional trailing path separator (e.g. `'/'`) + */ + static Segment fromTrustedString(string name, char separator = '\0') + nothrow pure { + import std.algorithm.searching : any; + assert(separator == '\0' || Format.isSeparator(separator)); + assert(Format.validateDecodedSegment(name) is null, "Invalid path segment."); + return fromTrustedEncodedString(Format.encodeSegment(name), separator); + } + + /** Constructs a path segment without performing validation. + + Note that in debug builds, there are still assertions in place + that verify that the provided values are valid. + + Params: + encoded_name = The encoded name of the path segment + separator = Optional trailing path separator (e.g. `'/'`) + */ + static Segment fromTrustedEncodedString(string encoded_name, char separator = '\0') + nothrow @nogc pure { + import std.algorithm.searching : any; + import std.utf : byCodeUnit; + + assert(separator == '\0' || Format.isSeparator(separator)); + assert(!encoded_name.byCodeUnit.any!(c => Format.isSeparator(c))); + assert(Format.validatePath(encoded_name) is null, "Invalid path segment."); + + Segment ret; + ret.m_encodedName = encoded_name; + ret.m_separator = separator; + return ret; + } + + /** The (file/directory) name of the path segment. + + Note: Depending on the path type, this may return a generic range + type instead of `string`. Use `name.to!string` in that + case if you need an actual `string`. + */ + @property auto name() + const nothrow @nogc { + auto ret = Format.decodeSingleSegment(m_encodedName); + + static if (is(typeof(ret) == string)) return ret; + else { + static struct R { + private typeof(ret) m_value; + + @property bool empty() const { return m_value.empty; } + @property R save() const { return R(m_value.save); } + @property char front() const { return m_value.front; } + @property void popFront() { m_value.popFront(); } + @property char back() const { return m_value.back; } + @property void popBack() { m_value.popBack(); } + + string toString() + const @safe nothrow { + import std.conv : to; + try return m_value.save.to!string; + catch (Exception e) assert(false, e.msg); + } + } + + return R(ret); } } - foreach( i, f; m_nodes ){ - if( i > 0 ) ret.put('/'); - ret.put(f.toString()); + unittest { + import std.conv : to; + auto path = InetPath("/foo%20bar"); + assert(path.head.encodedName == "foo%20bar"); + assert(path.head.name.toString() == "foo bar"); + assert(path.head.name.to!string == "foo bar"); + assert(path.head.name.equal("foo bar")); } - if( m_nodes.length > 0 && m_endsWithSlash ) - ret.put('/'); - return ret.data; - } + /// The encoded representation of the path segment name + @property string encodedName() const nothrow @nogc { return m_encodedName; } + /// The trailing separator (e.g. `'/'`) or `'\0'`. + @property char separator() const nothrow @nogc { return m_separator; } + /// ditto + @property void separator(char ch) { + enforce!PathValidationException(ch == '\0' || Format.isSeparator(ch), + "Character is not a valid path separator."); + m_separator = ch; + } + /// Returns `true` $(I iff) the segment has a trailing path separator. + @property bool hasSeparator() const nothrow @nogc { return m_separator != '\0'; } - /// Converts the NativePath object to a native path string (backslash as path separator on Windows). - string toNativeString() - const { - if (m_nodes.empty) { - version(Windows) { - assert(!absolute, "Empty absolute path detected."); - return m_endsWithSlash ? ".\\" : "."; - } else return absolute ? "/" : m_endsWithSlash ? "./" : "."; + + /** The extension part of the file name. + + If the file name contains an extension, this returns a forward range + with the extension including the leading dot. Otherwise an empty + range is returned. + + See_also: `stripExtension` + */ + @property auto extension() + const nothrow @nogc { + return .extension(this.name); + } + + /// + unittest { + assert(PosixPath("/foo/bar.txt").head.extension.equal(".txt")); + assert(PosixPath("/foo/bar").head.extension.equal("")); + assert(PosixPath("/foo/.bar").head.extension.equal("")); + assert(PosixPath("/foo/.bar.txt").head.extension.equal(".txt")); + } + + + /** Returns the file base name, excluding the extension. + + See_also: `extension` + */ + @property auto withoutExtension() + const nothrow @nogc { + return .stripExtension(this.name); + } + + /// + unittest { + assert(PosixPath("/foo/bar.txt").head.withoutExtension.equal("bar")); + assert(PosixPath("/foo/bar").head.withoutExtension.equal("bar")); + assert(PosixPath("/foo/.bar").head.withoutExtension.equal(".bar")); + assert(PosixPath("/foo/.bar.txt").head.withoutExtension.equal(".bar")); } - Appender!string ret; - // for absolute unix paths start with / - version(Posix) { if(absolute) ret.put('/'); } + /** Converts the segment to another path type. + + The segment name will be re-validated during the conversion. The + separator, if any, will be adopted or replaced by the default + separator of the target path type. - foreach( i, f; m_nodes ){ - version(Windows) { if( i > 0 ) ret.put('\\'); } - else version(Posix) { if( i > 0 ) ret.put('/'); } - else { static assert(0, "Unsupported OS"); } - ret.put(f.toString()); + Throws: + A `PathValidationException` is thrown if the segment name cannot + be represented in the target path format. + */ + GenericPath!F.Segment opCast(T : GenericPath!F.Segment, F)() + const { + import std.array : array; + + char dsep = '\0'; + if (m_separator) { + if (F.isSeparator(m_separator)) dsep = m_separator; + else dsep = F.defaultSeparator; + } + static if (is(typeof(this.name) == string)) + string n = this.name; + else + string n = this.name.array; + return GenericPath!F.Segment(n, dsep); } - if( m_nodes.length > 0 && m_endsWithSlash ){ - version(Windows) { ret.put('\\'); } - version(Posix) { ret.put('/'); } + /// Compares two path segment names + bool opEquals(Segment other) + const nothrow @nogc { + try return equal(this.name, other.name) && this.hasSeparator == other.hasSeparator; + catch (Exception e) assert(false, e.msg); + } + /// ditto + bool opEquals(string name) + const nothrow @nogc { + import std.utf : byCodeUnit; + try return equal(this.name, name.byCodeUnit); + catch (Exception e) assert(false, e.msg); } + } + + private { + string m_path; + } + + /// The default path segment separator character. + enum char defaultSeparator = Format.defaultSeparator; + + /** Constructs a path from its string representation. + + Throws: + A `PathValidationException` is thrown if the given path string + is not valid. + */ + this(string p) + { + auto err = Format.validatePath(p); + enforce!PathValidationException(err is null, err); + m_path = p; + } + + /** Constructs a path from a single path segment. + + This is equivalent to calling the range based constructor with a + single-element range. + */ + this(Segment segment) + { + import std.range : only; + this(only(segment)); + } + + /** Constructs a path from an input range of `Segment`s. - return ret.data; + Throws: + Since path segments are pre-validated, this constructor does not + throw an exception. + */ + this(R)(R segments) + if (isInputRange!R && is(ElementType!R : Segment)) + { + import std.array : appender; + auto dst = appender!string; + Format.toString(segments, dst); + m_path = dst.data; } - /// Tests if `rhs` is an ancestor or the same as this path. - bool startsWith(const NativePath rhs) const { - if( rhs.m_nodes.length > m_nodes.length ) return false; - foreach( i; 0 .. rhs.m_nodes.length ) - if( m_nodes[i] != rhs.m_nodes[i] ) - return false; - return true; + /** Constructs a path from its string representation. + + This is equivalent to calling the string based constructor. + */ + static GenericPath fromString(string p) + { + return GenericPath(p); } - /// Computes the relative path from `parentPath` to this path. - NativePath relativeTo(const NativePath parentPath) const { - assert(this.absolute && parentPath.absolute, "Determining relative path between non-absolute paths."); - version(Windows){ - // a path such as ..\C:\windows is not valid, so force the path to stay absolute in this case - if( this.absolute && !this.empty && - (m_nodes[0].toString().endsWith(":") && !parentPath.startsWith(this[0 .. 1]) || - m_nodes[0] == "\\" && !parentPath.startsWith(this[0 .. min(2, $)]))) + /** Constructs a path from its string representation, skipping the + validation. + + Note that it is required to pass a pre-validated path string + to this function. Debug builds will enforce this with an assertion. + */ + static GenericPath fromTrustedString(string p) + nothrow @nogc { + if (auto val = Format.validatePath(p)) + assert(false, val); + + GenericPath ret; + ret.m_path = p; + return ret; + } + + /// Tests if a certain character is a path segment separator. + static bool isSeparator(dchar ch) { return ch < 0x80 && Format.isSeparator(cast(char)ch); } + + /// Tests if the path is represented by an empty string. + @property bool empty() const nothrow @nogc { return m_path.length == 0; } + + /// Tests if the path is absolute. + @property bool absolute() const nothrow @nogc { return Format.getAbsolutePrefix(m_path).length > 0; } + + /// Determines whether the path ends with a path separator (i.e. represents a folder specifically). + @property bool endsWithSlash() const nothrow @nogc { return m_path.length > 0 && Format.isSeparator(m_path[$-1]); } + /// ditto + @property void endsWithSlash(bool v) + nothrow { + bool ews = this.endsWithSlash; + if (!ews && v) m_path ~= Format.defaultSeparator; + else if (ews && !v) m_path = m_path[0 .. $-1]; // FIXME?: "/test//" -> "/test/" + } + + /// vibe-core 1.x compatibility alias + alias bySegment2 = bySegment; + + /** Iterates over the individual segments of the path. + + Returns a forward range of `Segment`s. + */ + @property auto bySegment() + const { + static struct R { + import std.traits : ReturnType; + + private { + string m_path; + Segment m_front; + } + + private this(string path) + { + m_path = path; + if (m_path.length) { + auto ap = Format.getAbsolutePrefix(m_path); + if (ap.length && !Format.isSeparator(ap[0])) + m_front = Segment.fromTrustedEncodedString(null, Format.defaultSeparator); + else readFront(); + } + } + + @property bool empty() const nothrow @nogc { return m_path.length == 0 && m_front == Segment.init; } + + @property R save() { return this; } + + @property Segment front() { return m_front; } + + void popFront() + nothrow { + assert(m_front != Segment.init); + if (m_path.length) readFront(); + else m_front = Segment.init; + } + + private void readFront() { - return this; + auto n = Format.getFrontNode(m_path); + m_path = m_path[n.length .. $]; + + char sep = '\0'; + if (Format.isSeparator(n[$-1])) { + sep = n[$-1]; + n = n[0 .. $-1]; + } + m_front = Segment.fromTrustedEncodedString(n, sep); + assert(m_front != Segment.init); } } - int nup = 0; - while( parentPath.length > nup && !startsWith(parentPath[0 .. parentPath.length-nup]) ){ - nup++; - } - assert(m_nodes.length >= parentPath.length - nup); - NativePath ret = NativePath(null, false); - assert(m_nodes.length >= parentPath.length - nup); - ret.m_endsWithSlash = true; - foreach( i; 0 .. nup ) ret ~= ".."; - ret ~= NativePath(m_nodes[parentPath.length-nup .. $], false); - ret.m_endsWithSlash = this.m_endsWithSlash; - return ret; + + return R(m_path); } - /// The last entry of the path - @property ref immutable(PathEntry) head() const { enforce(m_nodes.length > 0, "Getting head of empty path."); return m_nodes[$-1]; } + /// + unittest { + InetPath p = "foo/bar/baz"; + assert(p.bySegment.equal([ + InetPath.Segment("foo", '/'), + InetPath.Segment("bar", '/'), + InetPath.Segment("baz") + ])); + } - /// The parent path - @property NativePath parentPath() const { return this[0 .. length-1]; } - /// The list of path entries of which this path is composed - @property immutable(PathEntry)[] nodes() const { return m_nodes; } + /** Iterates over the path by segment, each time returning the sub path + leading to that segment. + */ + @property auto byPrefix() + const nothrow @nogc { + static struct R { + import std.traits : ReturnType; - /// The number of path entries of which this path is composed - @property size_t length() const scope @safe pure nothrow @nogc { return m_nodes.length; } + private { + string m_path; + string m_remainder; + } - /// True if the path contains no entries - @property bool empty() const scope @safe pure nothrow @nogc { return m_nodes.length == 0; } + private this(string path) + { + m_path = path; + m_remainder = path; + if (m_path.length) { + auto ap = Format.getAbsolutePrefix(m_path); + if (ap.length && !Format.isSeparator(ap[0])) + m_remainder = m_remainder[ap.length .. $]; + else popFront(); + } + } + + @property bool empty() const nothrow @nogc + { + return m_path.length == 0; + } + + @property R save() { return this; } + + @property GenericPath front() + { + return GenericPath.fromTrustedString(m_path[0 .. $-m_remainder.length]); + } + + void popFront() + nothrow { + assert(m_remainder.length > 0 || m_path.length > 0); + if (m_remainder.length) readFront(); + else m_path = ""; + } + + private void readFront() + { + auto n = Format.getFrontNode(m_remainder); + m_remainder = m_remainder[n.length .. $]; + } + } + + return R(m_path); + } + + /// + unittest { + assert(InetPath("foo/bar/baz").byPrefix + .equal([ + InetPath("foo/"), + InetPath("foo/bar/"), + InetPath("foo/bar/baz") + ])); + + assert(InetPath("/foo/bar").byPrefix + .equal([ + InetPath("/"), + InetPath("/foo/"), + InetPath("/foo/bar"), + ])); + } + + // vibe-core 1.x compatibility alias + alias head2 = head; + + /// Returns the trailing segment of the path. + @property Segment head() + const @nogc { + auto n = Format.getBackNode(m_path); + char sep = '\0'; + if (n.length > 0 && Format.isSeparator(n[$-1])) { + sep = n[$-1]; + n = n[0 .. $-1]; + } + return Segment.fromTrustedEncodedString(n, sep); + } + + /** Determines if the `parentPath` property is valid. + */ + @property bool hasParentPath() + const @nogc { + auto b = Format.getBackNode(m_path); + return b.length < m_path.length; + } + + /** Returns a prefix of this path, where the last segment has been dropped. + + Throws: + An `Exception` is thrown if this path has no parent path. Use + `hasParentPath` to test this upfront. + */ + @property GenericPath parentPath() + const @nogc { + auto b = Format.getBackNode(m_path); + () @trusted { + static __gshared e = new Exception("Path has no parent path"); + if (b.length >= m_path.length) throw e; + } (); + return GenericPath.fromTrustedString(m_path[0 .. $ - b.length]); + } + + + /** The extension part of the file name pointed to by the path. + + If the path is not empty and its head segment has an extension, this + returns a forward range with the extension including the leading dot. + Otherwise an empty range is returned. + + See `Segment.extension` for a full description. + + See_also: `Segment.extension`, `Segment.stripExtension` + */ + @property auto fileExtension() + const nothrow @nogc { + if (this.empty) return typeof(this.head.extension).init; + return this.head.extension; + } - /// Determines if the path ends with a slash (i.e. is a directory) - @property bool endsWithSlash() const { return m_endsWithSlash; } - /// ditto - @property void endsWithSlash(bool v) { m_endsWithSlash = v; } - /// Determines if this path goes outside of its base path (i.e. begins with '..'). - @property bool external() const { return !m_absolute && m_nodes.length > 0 && m_nodes[0].m_name == ".."; } + /** Returns the normalized form of the path. - ref immutable(PathEntry) opIndex(size_t idx) const { return m_nodes[idx]; } - NativePath opSlice(size_t start, size_t end) const { - auto ret = NativePath(m_nodes[start .. end], start == 0 ? absolute : false); - if( end == m_nodes.length ) ret.m_endsWithSlash = m_endsWithSlash; + See `normalize` for a full description. + */ + @property GenericPath normalized() + const { + GenericPath ret = this; + ret.normalize(); return ret; } - size_t opDollar(int dim)() const if(dim == 0) { return m_nodes.length; } + unittest { + assert(PosixPath("foo/../bar").normalized == PosixPath("bar")); + assert(PosixPath("foo//./bar/../baz").normalized == PosixPath("foo/baz")); + } + + + /** Removes any redundant path segments and replaces all separators by the + default one. + + The resulting path representation is suitable for basic semantic + comparison to other normalized paths. - NativePath opBinary(string OP)(const NativePath rhs) const if( OP == "~" ) { - NativePath ret; - ret.m_nodes = m_nodes; - ret.m_absolute = m_absolute; - ret.m_endsWithSlash = rhs.m_endsWithSlash; - ret.normalize(); // needed to avoid "."~".." become "" instead of ".." + Note that there are still ways for different normalized paths to + represent the same file. Examples of this are the tilde shortcut to the + home directory on Unix and Linux operating systems, symbolic or hard + links, and possibly environment variables are examples of this. - assert(!rhs.absolute, "Trying to append absolute path."); - foreach(folder; rhs.m_nodes){ - switch(folder.toString()){ - default: ret.m_nodes = ret.m_nodes ~ folder; break; + Throws: + Throws an `Exception` if an absolute path contains parent directory + segments ("..") that lead to a path that is a parent path of the + root path. + */ + void normalize() + { + import std.array : appender, join; + + Segment[] newnodes; + bool got_non_sep = false; + foreach (n; this.bySegment) { + if (n.hasSeparator) n.separator = Format.defaultSeparator; + if (!got_non_sep) { + if (n.encodedName == "") newnodes ~= n; + else got_non_sep = true; + } + switch (n.encodedName) { + default: newnodes ~= n; break; case "", ".": break; case "..": - enforce(!ret.absolute || ret.m_nodes.length > 0, "Relative path goes below root node!"); - if( ret.m_nodes.length > 0 && ret.m_nodes[$-1].toString() != ".." ) - ret.m_nodes = ret.m_nodes[0 .. $-1]; - else ret.m_nodes = ret.m_nodes ~ folder; + enforce(!this.absolute || newnodes.length > 0, "Path goes below root node."); + if (newnodes.length > 0 && newnodes[$-1].encodedName != "..") newnodes = newnodes[0 .. $-1]; + else newnodes ~= n; break; } } - return ret; + + auto dst = appender!string; + Format.toString(newnodes, dst); + m_path = dst.data; } - NativePath opBinary(string OP)(string rhs) const if( OP == "~" ) { assert(rhs.length > 0, "Cannot append empty path string."); return opBinary!"~"(NativePath(rhs)); } - NativePath opBinary(string OP)(PathEntry rhs) const if( OP == "~" ) { assert(rhs.toString().length > 0, "Cannot append empty path string."); return opBinary!"~"(NativePath(rhs)); } - void opOpAssign(string OP)(string rhs) if( OP == "~" ) { assert(rhs.length > 0, "Cannot append empty path string."); opOpAssign!"~"(NativePath(rhs)); } - void opOpAssign(string OP)(PathEntry rhs) if( OP == "~" ) { assert(rhs.toString().length > 0, "Cannot append empty path string."); opOpAssign!"~"(NativePath(rhs)); } - void opOpAssign(string OP)(NativePath rhs) if( OP == "~" ) { auto p = this ~ rhs; m_nodes = p.m_nodes; m_endsWithSlash = rhs.m_endsWithSlash; } + /// + unittest { + auto path = WindowsPath("C:\\test/foo/./bar///../baz"); + path.normalize(); + assert(path.toString() == "C:\\test\\foo\\baz", path.toString()); - /// Tests two paths for equality using '=='. - bool opEquals(scope ref const NativePath rhs) const scope @safe { - if( m_absolute != rhs.m_absolute ) return false; - if( m_endsWithSlash != rhs.m_endsWithSlash ) return false; - if( m_nodes.length != rhs.length ) return false; - foreach( i; 0 .. m_nodes.length ) - if( m_nodes[i] != rhs.m_nodes[i] ) - return false; - return true; + path = WindowsPath("foo/../../bar/"); + path.normalize(); + assert(path.toString() == "..\\bar\\"); } - /// ditto - bool opEquals(scope const NativePath other) const scope @safe { return opEquals(other); } - - int opCmp(ref const NativePath rhs) const { - if( m_absolute != rhs.m_absolute ) return cast(int)m_absolute - cast(int)rhs.m_absolute; - foreach( i; 0 .. min(m_nodes.length, rhs.m_nodes.length) ) - if( m_nodes[i] != rhs.m_nodes[i] ) - return m_nodes[i].opCmp(rhs.m_nodes[i]); - if( m_nodes.length > rhs.m_nodes.length ) return 1; - if( m_nodes.length < rhs.m_nodes.length ) return -1; - return 0; - } - - size_t toHash() - const nothrow @trusted { - size_t ret; - auto strhash = &typeid(string).getHash; - try foreach (n; nodes) ret ^= strhash(&n.m_name); - catch (Exception) assert(false); - if (m_absolute) ret ^= 0xfe3c1738; - if (m_endsWithSlash) ret ^= 0x6aa4352d; - return ret; + + /// Returns the string representation of the path. + string toString() const nothrow @nogc { return m_path; } + + /// Computes a hash sum, enabling storage within associative arrays. + size_t toHash() const nothrow @trusted + { + try return typeid(string).getHash(&m_path); + catch (Exception e) assert(false, "getHash for string throws!?"); } -} -struct PathEntry { - private { - string m_name; + /** Compares two path objects. + + Note that the exact string representation of the two paths will be + compared. To get a basic semantic comparison, the paths must be + normalized first. + */ + bool opEquals(GenericPath other) const @nogc { return this.m_path == other.m_path; } + + /** Converts the path to a different path format. + + Throws: + A `PathValidationException` will be thrown if the path is not + representable in the requested path format. This can happen + especially when converting Posix or Internet paths to windows paths, + since Windows paths cannot contain a number of characters that the + other representations can, in theory. + */ + P opCast(P)() const if (isInstanceOf!(.GenericPath, P)) { + static if (is(P == GenericPath)) return this; + else return P(this.bySegment.map!(n => cast(P.Segment)n)); } - this(string str) - pure { - assert(str.countUntil('/') < 0 && (str.countUntil('\\') < 0 || str.length == 1)); - m_name = str; + /** Concatenates two paths. + + The right hand side must represent a relative path. + */ + GenericPath opBinary(string op : "~")(string subpath) const { return this ~ GenericPath(subpath); } + /// ditto + GenericPath opBinary(string op : "~")(Segment subpath) const { return this ~ GenericPath(subpath); } + /// ditto + GenericPath opBinary(string op : "~", F)(GenericPath!F.Segment subpath) const { return this ~ cast(Segment)(subpath); } + /// ditto + GenericPath opBinary(string op : "~")(GenericPath subpath) const nothrow { + assert(!subpath.absolute || m_path.length == 0, "Cannot append absolute path."); + if (endsWithSlash || empty) return GenericPath.fromTrustedString(m_path ~ subpath.m_path); + else return GenericPath.fromTrustedString(m_path ~ Format.defaultSeparator ~ subpath.m_path); + } + /// ditto + GenericPath opBinary(string op : "~", F)(GenericPath!F subpath) const if (!is(F == Format)) { return this ~ cast(GenericPath)subpath; } + /// ditto + GenericPath opBinary(string op : "~", R)(R entries) const nothrow + if (isInputRange!R && is(ElementType!R : Segment)) + { + return this ~ GenericPath(entries); } - string toString() const return scope @safe pure nothrow @nogc { return m_name; } + /// Appends a relative path to this path. + void opOpAssign(string op : "~", T)(T op) { this = this ~ op; } - @property string name() const return scope @safe pure nothrow @nogc { return m_name; } + /** Tests whether the given path is a prefix of this path. - NativePath opBinary(string OP)(PathEntry rhs) const if( OP == "~" ) { return NativePath([this, rhs], false); } + Any path separators will be ignored during the comparison. + */ + bool startsWith(GenericPath prefix) + const nothrow { + return bySegment.map!(n => n.name).startsWith(prefix.bySegment.map!(n => n.name)); + } +} - bool opEquals(scope ref const PathEntry rhs) const scope @safe pure nothrow @nogc { return m_name == rhs.m_name; } - bool opEquals(scope PathEntry rhs) const scope @safe pure nothrow @nogc { return m_name == rhs.m_name; } - bool opEquals(string rhs) const scope @safe pure nothrow @nogc { return m_name == rhs; } - int opCmp(scope ref const PathEntry rhs) const scope @safe pure nothrow @nogc { return m_name.cmp(rhs.m_name); } - int opCmp(string rhs) const scope @safe pure nothrow @nogc { return m_name.cmp(rhs); } +unittest { + assert(PosixPath("hello/world").bySegment.equal([PosixPath.Segment("hello",'/'), PosixPath.Segment("world")])); + assert(PosixPath("/hello/world/").bySegment.equal([PosixPath.Segment("",'/'), PosixPath.Segment("hello",'/'), PosixPath.Segment("world",'/')])); + assert(PosixPath("hello\\world").bySegment.equal([PosixPath.Segment("hello\\world")])); + assert(WindowsPath("hello/world").bySegment.equal([WindowsPath.Segment("hello",'/'), WindowsPath.Segment("world")])); + assert(WindowsPath("/hello/world/").bySegment.equal([WindowsPath.Segment("",'/'), WindowsPath.Segment("hello",'/'), WindowsPath.Segment("world",'/')])); + assert(WindowsPath("hello\\w/orld").bySegment.equal([WindowsPath.Segment("hello",'\\'), WindowsPath.Segment("w",'/'), WindowsPath.Segment("orld")])); + assert(WindowsPath("hello/w\\orld").bySegment.equal([WindowsPath.Segment("hello",'/'), WindowsPath.Segment("w",'\\'), WindowsPath.Segment("orld")])); + + assert(PosixPath("hello/world").byPrefix.equal([PosixPath("hello/"), PosixPath("hello/world")])); + assert(PosixPath("/hello/world/").byPrefix.equal([PosixPath("/"), PosixPath("/hello/"), PosixPath("/hello/world/")])); + assert(WindowsPath("C:\\Windows").byPrefix.equal([WindowsPath("C:\\"), WindowsPath("C:\\Windows")])); } -/// Joins two path strings. sub-path must be relative. -string joinPath(string basepath, string subpath) +unittest { - NativePath p1 = NativePath(basepath); - NativePath p2 = NativePath(subpath); - return (p1 ~ p2).toString(); -} + { + auto dotpath = "/test/../test2/././x/y"; + auto dotpathp = PosixPath(dotpath); + assert(dotpathp.toString() == "/test/../test2/././x/y"); + dotpathp.normalize(); + assert(dotpathp.toString() == "/test2/x/y", dotpathp.toString()); + } -/// Splits up a path string into its elements/folders -PathEntry[] splitPath(string path) -pure { - if( path.startsWith("/") || path.startsWith("\\") ) path = path[1 .. $]; - if( path.empty ) return null; - if( path.endsWith("/") || path.endsWith("\\") ) path = path[0 .. $-1]; - - // count the number of path nodes - size_t nelements = 0; - foreach( i, char ch; path ) - if( ch == '\\' || ch == '/' ) - nelements++; - nelements++; - - // reserve space for the elements - auto elements = new PathEntry[nelements]; - size_t eidx = 0; - - // detect UNC path - if(path.startsWith("\\")) { - elements[eidx++] = PathEntry(path[0 .. 1]); - path = path[1 .. $]; + auto dotpath = "/test/..////test2//./x/y"; + auto dotpathp = PosixPath(dotpath); + assert(dotpathp.toString() == "/test/..////test2//./x/y"); + dotpathp.normalize(); + assert(dotpathp.toString() == "/test2/x/y"); } - // read and return the elements - size_t startidx = 0; - foreach( i, char ch; path ) - if( ch == '\\' || ch == '/' ){ - elements[eidx++] = PathEntry(path[startidx .. i]); - startidx = i+1; - } - elements[eidx++] = PathEntry(path[startidx .. $]); - assert(eidx == nelements); - return elements; -} + assert(WindowsPath("C:\\Windows").absolute); + assert((cast(InetPath)WindowsPath("C:\\Windows")).toString() == "/C:/Windows"); + assert((WindowsPath("C:\\Windows") ~ InetPath("test/this")).toString() == "C:\\Windows\\test/this"); + assert(InetPath("/C:/Windows").absolute); + assert((cast(WindowsPath)InetPath("/C:/Windows")).toString() == "C:/Windows"); + assert((InetPath("/C:/Windows") ~ WindowsPath("test\\this")).toString() == "/C:/Windows/test/this"); + assert((InetPath("") ~ WindowsPath("foo\\bar")).toString() == "foo/bar"); + assert((cast(InetPath)WindowsPath("C:\\Windows\\")).toString() == "/C:/Windows/"); -unittest -{ - NativePath p; - assert(p.toNativeString() == "."); - p.endsWithSlash = true; - version(Windows) assert(p.toNativeString() == ".\\"); - else assert(p.toNativeString() == "./"); - - p = NativePath("test/"); - version(Windows) assert(p.toNativeString() == "test\\"); - else assert(p.toNativeString() == "test/"); - p.endsWithSlash = false; - assert(p.toNativeString() == "test"); -} + assert(NativePath("").empty); + + assert(PosixPath("/") ~ NativePath("foo/bar") == PosixPath("/foo/bar")); + assert(PosixPath("") ~ NativePath("foo/bar") == PosixPath("foo/bar")); + assert(PosixPath("foo") ~ NativePath("bar") == PosixPath("foo/bar")); + assert(PosixPath("foo/") ~ NativePath("bar") == PosixPath("foo/bar")); -unittest -{ { auto unc = "\\\\server\\share\\path"; - auto uncp = NativePath(unc); + auto uncp = WindowsPath(unc); + assert(uncp.absolute); uncp.normalize(); version(Windows) assert(uncp.toNativeString() == unc); assert(uncp.absolute); @@ -373,105 +918,835 @@ unittest { auto abspath = "/test/path/"; - auto abspathp = NativePath(abspath); + auto abspathp = PosixPath(abspath); assert(abspathp.toString() == abspath); version(Windows) {} else assert(abspathp.toNativeString() == abspath); assert(abspathp.absolute); assert(abspathp.endsWithSlash); - assert(abspathp.length == 2); - assert(abspathp[0] == "test"); - assert(abspathp[1] == "path"); + alias S = PosixPath.Segment; + assert(abspathp.bySegment.equal([S("", '/'), S("test", '/'), S("path", '/')])); } { auto relpath = "test/path/"; - auto relpathp = NativePath(relpath); + auto relpathp = PosixPath(relpath); assert(relpathp.toString() == relpath); - version(Windows) assert(relpathp.toNativeString() == "test\\path\\"); + version(Windows) assert(relpathp.toNativeString() == "test/path/"); else assert(relpathp.toNativeString() == relpath); assert(!relpathp.absolute); assert(relpathp.endsWithSlash); - assert(relpathp.length == 2); - assert(relpathp[0] == "test"); - assert(relpathp[1] == "path"); + alias S = PosixPath.Segment; + assert(relpathp.bySegment.equal([S("test", '/'), S("path", '/')])); } { auto winpath = "C:\\windows\\test"; - auto winpathp = NativePath(winpath); - version(Windows) { - assert(winpathp.toString() == "C:/windows/test", winpathp.toString()); - assert(winpathp.toNativeString() == winpath); - } else { - assert(winpathp.toString() == "/C:/windows/test", winpathp.toString()); - assert(winpathp.toNativeString() == "/C:/windows/test"); - } + auto winpathp = WindowsPath(winpath); + assert(winpathp.toString() == "C:\\windows\\test"); + assert((cast(PosixPath)winpathp).toString() == "/C:/windows/test", (cast(PosixPath)winpathp).toString()); + version(Windows) assert(winpathp.toNativeString() == winpath); + else assert(winpathp.toNativeString() == "/C:/windows/test"); assert(winpathp.absolute); assert(!winpathp.endsWithSlash); - assert(winpathp.length == 3); - assert(winpathp[0] == "C:"); - assert(winpathp[1] == "windows"); - assert(winpathp[2] == "test"); + alias S = WindowsPath.Segment; + assert(winpathp.bySegment.equal([S("", '/'), S("C:", '\\'), S("windows", '\\'), S("test")])); + } +} + +@safe unittest { + import std.array : appender; + auto app = appender!(PosixPath[]); + void test1(PosixPath p) { app.put(p); } + void test2(PosixPath[] ps) { app.put(ps); } + //void test3(const(PosixPath) p) { app.put(p); } // DMD issue 17251 + //void test4(const(PosixPath)[] ps) { app.put(ps); } +} + +unittest { + import std.exception : assertThrown, assertNotThrown; + + assertThrown!PathValidationException(WindowsPath.Segment("foo/bar")); + assertThrown!PathValidationException(PosixPath.Segment("foo/bar")); + assertNotThrown!PathValidationException(InetPath.Segment("foo/bar")); + + auto p = InetPath("/foo%2fbar/"); + import std.conv : to; + assert(p.bySegment.equal([InetPath.Segment("",'/'), InetPath.Segment("foo/bar",'/')]), p.bySegment.to!string); + p ~= InetPath.Segment("baz/bam"); + assert(p.toString() == "/foo%2fbar/baz%2Fbam", p.toString); +} + +unittest { + assert(!PosixPath("").hasParentPath); + assert(!PosixPath("/").hasParentPath); + assert(!PosixPath("foo\\bar").hasParentPath); + assert(PosixPath("foo/bar").parentPath.toString() == "foo/"); + assert(PosixPath("./foo").parentPath.toString() == "./"); + assert(PosixPath("./foo").parentPath.toString() == "./"); + + assert(!WindowsPath("").hasParentPath); + assert(!WindowsPath("/").hasParentPath); + assert(WindowsPath("foo\\bar").parentPath.toString() == "foo\\"); + assert(WindowsPath("foo/bar").parentPath.toString() == "foo/"); + assert(WindowsPath("./foo").parentPath.toString() == "./"); + assert(WindowsPath("./foo").parentPath.toString() == "./"); + + assert(!InetPath("").hasParentPath); + assert(!InetPath("/").hasParentPath); + assert(InetPath("foo/bar").parentPath.toString() == "foo/"); + assert(InetPath("foo/bar%2Fbaz").parentPath.toString() == "foo/"); + assert(InetPath("./foo").parentPath.toString() == "./"); + assert(InetPath("./foo").parentPath.toString() == "./"); +} + +unittest { + assert(WindowsPath([WindowsPath.Segment("foo"), WindowsPath.Segment("bar")]).toString() == "foo\\bar"); +} + +unittest { + assert(WindowsPath([WindowsPath.Segment("foo"), WindowsPath.Segment("bar")]).toString() == "foo\\bar"); +} + +/// Thrown when an invalid string representation of a path is detected. +class PathValidationException : Exception { + this(string text, string file = __FILE__, size_t line = cast(size_t)__LINE__, Throwable next = null) + pure nothrow @nogc @safe + { + super(text, file, line, next); } +} +/** Implements Windows path semantics. + + See_also: `WindowsPath` +*/ +struct WindowsPathFormat { + static void toString(I, O)(I segments, O dst) + if (isInputRange!I && isOutputRange!(O, char)) { - auto dotpath = "/test/../test2/././x/y"; - auto dotpathp = NativePath(dotpath); - assert(dotpathp.toString() == "/test/../test2/././x/y"); - dotpathp.normalize(); - assert(dotpathp.toString() == "/test2/x/y"); + char sep(char s) { return isSeparator(s) ? s : defaultSeparator; } + + if (segments.empty) return; + + if (segments.front.name == "" && segments.front.separator) { + auto s = segments.front.separator; + segments.popFront(); + if (segments.empty || !segments.front.name.endsWith(":")) + dst.put(sep(s)); + } + + char lastsep = '\0'; + bool first = true; + foreach (s; segments) { + if (!first || lastsep) dst.put(sep(lastsep)); + else first = false; + dst.put(s.name); + lastsep = s.separator; + } + if (lastsep) dst.put(sep(lastsep)); } + unittest { + import std.array : appender; + struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }} + string str(Segment[] segs...) { auto ret = appender!string; toString(segs, ret); return ret.data; } + + assert(str() == ""); + assert(str(Segment("",'/')) == "/"); + assert(str(Segment("",'/'), Segment("foo")) == "/foo"); + assert(str(Segment("",'\\')) == "\\"); + assert(str(Segment("foo",'/'), Segment("bar",'/')) == "foo/bar/"); + assert(str(Segment("",'/'), Segment("foo",'\0')) == "/foo"); + assert(str(Segment("",'\\'), Segment("foo",'\\')) == "\\foo\\"); + assert(str(Segment("f oo")) == "f oo"); + assert(str(Segment("",'\\'), Segment("C:")) == "C:"); + assert(str(Segment("",'\\'), Segment("C:", '/')) == "C:/"); + assert(str(Segment("foo",'\\'), Segment("C:")) == "foo\\C:"); + assert(str(Segment("foo"), Segment("bar")) == "foo\\bar"); + } + +@safe nothrow pure: + enum defaultSeparator = '\\'; + + static bool isSeparator(dchar ch) + @nogc { + return ch == '\\' || ch == '/'; + } + + static string getAbsolutePrefix(string path) + @nogc { + if (!path.length) return null; + + if (isSeparator(path[0])) { + return path[0 .. 1]; + } + + foreach (i; 1 .. path.length) + if (isSeparator(path[i])) { + if (path[i-1] == ':') return path[0 .. i+1]; + break; + } + + return path[$-1] == ':' ? path : null; + } + + unittest { + assert(getAbsolutePrefix("test") == ""); + assert(getAbsolutePrefix("test/") == ""); + assert(getAbsolutePrefix("/test") == "/"); + assert(getAbsolutePrefix("\\test") == "\\"); + assert(getAbsolutePrefix("C:\\") == "C:\\"); + assert(getAbsolutePrefix("C:") == "C:"); + assert(getAbsolutePrefix("C:\\test") == "C:\\"); + assert(getAbsolutePrefix("C:\\test\\") == "C:\\"); + assert(getAbsolutePrefix("C:/") == "C:/"); + assert(getAbsolutePrefix("C:/test") == "C:/"); + assert(getAbsolutePrefix("C:/test/") == "C:/"); + assert(getAbsolutePrefix("\\\\server") == "\\"); + assert(getAbsolutePrefix("\\\\server\\") == "\\"); + assert(getAbsolutePrefix("\\\\.\\") == "\\"); + assert(getAbsolutePrefix("\\\\?\\") == "\\"); + } + + static string getFrontNode(string path) + @nogc { + foreach (i; 0 .. path.length) + if (isSeparator(path[i])) + return path[0 .. i+1]; + return path; + } + + unittest { + assert(getFrontNode("") == ""); + assert(getFrontNode("/bar") == "/"); + assert(getFrontNode("foo/bar") == "foo/"); + assert(getFrontNode("foo/") == "foo/"); + assert(getFrontNode("foo") == "foo"); + assert(getFrontNode("\\bar") == "\\"); + assert(getFrontNode("foo\\bar") == "foo\\"); + assert(getFrontNode("foo\\") == "foo\\"); + } + + static string getBackNode(string path) + @nogc { + if (!path.length) return path; + foreach_reverse (i; 0 .. path.length-1) + if (isSeparator(path[i])) + return path[i+1 .. $]; + return path; + } + + unittest { + assert(getBackNode("") == ""); + assert(getBackNode("/bar") == "bar"); + assert(getBackNode("foo/bar") == "bar"); + assert(getBackNode("foo/") == "foo/"); + assert(getBackNode("foo") == "foo"); + assert(getBackNode("\\bar") == "bar"); + assert(getBackNode("foo\\bar") == "bar"); + assert(getBackNode("foo\\") == "foo\\"); + } + + static string decodeSingleSegment(string segment) + @nogc { + assert(segment.length == 0 || segment[$-1] != '/'); + return segment; + } + + unittest { + struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }} + assert(decodeSingleSegment("foo") == "foo"); + assert(decodeSingleSegment("fo%20o") == "fo%20o"); + assert(decodeSingleSegment("C:") == "C:"); + assert(decodeSingleSegment("bar:") == "bar:"); + } + + static string validatePath(string path) + @nogc { + import std.algorithm.comparison : among; + + // skip UNC prefix + if (path.startsWith("\\\\")) { + path = path[2 .. $]; + while (path.length && !isSeparator(path[0])) { + if (path[0] < 32 || path[0].among('<', '>', '|')) + return "Invalid character in UNC host name."; + path = path[1 .. $]; + } + if (path.length) path = path[1 .. $]; + } + + // stricter validation for the rest + bool had_sep = false; + foreach (i, char c; path) { + if (c < 32 || c.among!('<', '>', '|', '?')) + return "Invalid character in path."; + if (isSeparator(c)) had_sep = true; + else if (c == ':' && (had_sep || i+1 < path.length && !isSeparator(path[i+1]))) + return "Colon in path that is not part of a drive name."; + + } + return null; + } + + static string validateDecodedSegment(string segment) + @nogc { + auto pe = validatePath(segment); + if (pe) return pe; + foreach (char c; segment) + if (isSeparator(c)) + return "Path segment contains separator character."; + return null; + } + + unittest { + assert(validatePath("c:\\foo") is null); + assert(validatePath("\\\\?\\c:\\foo") is null); + assert(validatePath("//?\\c:\\foo") !is null); + assert(validatePath("-foo/bar\\*\\baz") is null); + assert(validatePath("foo\0bar") !is null); + assert(validatePath("foo\tbar") !is null); + assert(validatePath("\\c:\\foo") !is null); + assert(validatePath("c:d\\foo") !is null); + assert(validatePath("foo\\b:ar") !is null); + assert(validatePath("foo\\bar:\\baz") !is null); + } + + static string encodeSegment(string segment) { - auto dotpath = "/test/..////test2//./x/y"; - auto dotpathp = NativePath(dotpath); - assert(dotpathp.toString() == "/test/..////test2//./x/y"); - dotpathp.normalize(); - assert(dotpathp.toString() == "/test2/x/y"); + assert(segment.length == 0 || segment[$-1] != '/'); + return segment; } +} + +/** Implements Unix/Linux path semantics. + + See_also: `WindowsPath` +*/ +struct PosixPathFormat { + static void toString(I, O)(I segments, O dst) { - auto parentpath = "/path/to/parent"; - auto parentpathp = NativePath(parentpath); - auto subpath = "/path/to/parent/sub/"; - auto subpathp = NativePath(subpath); - auto subpath_rel = "sub/"; - assert(subpathp.relativeTo(parentpathp).toString() == subpath_rel); - auto subfile = "/path/to/parent/child"; - auto subfilep = NativePath(subfile); - auto subfile_rel = "child"; - assert(subfilep.relativeTo(parentpathp).toString() == subfile_rel); + char lastsep = '\0'; + bool first = true; + foreach (s; segments) { + if (!first || lastsep) dst.put('/'); + else first = false; + dst.put(s.name); + lastsep = s.separator; + } + if (lastsep) dst.put('/'); } - { // relative paths across Windows devices are not allowed - version (Windows) { - auto p1 = NativePath("\\\\server\\share"); assert(p1.absolute); - auto p2 = NativePath("\\\\server\\othershare"); assert(p2.absolute); - auto p3 = NativePath("\\\\otherserver\\share"); assert(p3.absolute); - auto p4 = NativePath("C:\\somepath"); assert(p4.absolute); - auto p5 = NativePath("C:\\someotherpath"); assert(p5.absolute); - auto p6 = NativePath("D:\\somepath"); assert(p6.absolute); - assert(p4.relativeTo(p5) == NativePath("../somepath")); - assert(p4.relativeTo(p6) == NativePath("C:\\somepath")); - assert(p4.relativeTo(p1) == NativePath("C:\\somepath")); - assert(p1.relativeTo(p2) == NativePath("../share")); - assert(p1.relativeTo(p3) == NativePath("\\\\server\\share")); - assert(p1.relativeTo(p4) == NativePath("\\\\server\\share")); + unittest { + import std.array : appender; + struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }} + string str(Segment[] segs...) { auto ret = appender!string; toString(segs, ret); return ret.data; } + + assert(str() == ""); + assert(str(Segment("",'/')) == "/"); + assert(str(Segment("foo",'/'), Segment("bar",'/')) == "foo/bar/"); + assert(str(Segment("",'/'), Segment("foo",'\0')) == "/foo"); + assert(str(Segment("",'\\'), Segment("foo",'\\')) == "/foo/"); + assert(str(Segment("f oo")) == "f oo"); + assert(str(Segment("foo"), Segment("bar")) == "foo/bar"); + } + +@safe nothrow pure: + enum defaultSeparator = '/'; + + static bool isSeparator(dchar ch) + @nogc { + return ch == '/'; + } + + static string getAbsolutePrefix(string path) + @nogc { + if (path.length > 0 && path[0] == '/') + return path[0 .. 1]; + return null; + } + + unittest { + assert(getAbsolutePrefix("/") == "/"); + assert(getAbsolutePrefix("/test") == "/"); + assert(getAbsolutePrefix("/test/") == "/"); + assert(getAbsolutePrefix("test/") == ""); + assert(getAbsolutePrefix("") == ""); + assert(getAbsolutePrefix("./") == ""); + } + + static string getFrontNode(string path) + @nogc { + import std.string : indexOf; + auto idx = path.indexOf('/'); + return idx < 0 ? path : path[0 .. idx+1]; + } + + unittest { + assert(getFrontNode("") == ""); + assert(getFrontNode("/bar") == "/"); + assert(getFrontNode("foo/bar") == "foo/"); + assert(getFrontNode("foo/") == "foo/"); + assert(getFrontNode("foo") == "foo"); + } + + static string getBackNode(string path) + @nogc { + if (!path.length) return path; + foreach_reverse (i; 0 .. path.length-1) + if (path[i] == '/') + return path[i+1 .. $]; + return path; + } + + unittest { + assert(getBackNode("") == ""); + assert(getBackNode("/bar") == "bar"); + assert(getBackNode("foo/bar") == "bar"); + assert(getBackNode("foo/") == "foo/"); + assert(getBackNode("foo") == "foo"); + } + + static string validatePath(string path) + @nogc { + foreach (char c; path) + if (c == '\0') + return "Invalid NUL character in file name"; + return null; + } + + static string validateDecodedSegment(string segment) + @nogc { + auto pe = validatePath(segment); + if (pe) return pe; + foreach (char c; segment) + if (isSeparator(c)) + return "Path segment contains separator character."; + return null; + } + + unittest { + assert(validatePath("-foo/bar*/baz?") is null); + assert(validatePath("foo\0bar") !is null); + } + + static string decodeSingleSegment(string segment) + @nogc { + assert(segment.length == 0 || segment[$-1] != '/'); + return segment; + } + + unittest { + struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }} + assert(decodeSingleSegment("foo") == "foo"); + assert(decodeSingleSegment("fo%20o\\") == "fo%20o\\"); + } + + static string encodeSegment(string segment) + { + assert(segment.length == 0 || segment[$-1] != '/'); + return segment; + } +} + + +/** Implements URI/Internet path semantics. + + See_also: `WindowsPath` +*/ +struct InetPathFormat { + static void toString(I, O)(I segments, O dst) + { + char lastsep = '\0'; + bool first = true; + foreach (e; segments) { + if (!first || lastsep) dst.put('/'); + else first = false; + static if (is(typeof(e.encodedName))) + dst.put(e.encodedName); + else encodeSegment(dst, e.name); + lastsep = e.separator; + } + if (lastsep) dst.put('/'); + } + + unittest { + import std.array : appender; + struct Segment { string name; char separator = 0; static Segment fromTrustedString(string str, char sep = 0) pure nothrow @nogc { return Segment(str, sep); }} + string str(Segment[] segs...) { auto ret = appender!string; toString(segs, ret); return ret.data; } + assert(str() == ""); + assert(str(Segment("",'/')) == "/"); + assert(str(Segment("foo",'/'), Segment("bar",'/')) == "foo/bar/"); + assert(str(Segment("",'/'), Segment("foo",'\0')) == "/foo"); + assert(str(Segment("",'\\'), Segment("foo",'\\')) == "/foo/"); + assert(str(Segment("f oo")) == "f%20oo"); + assert(str(Segment("foo"), Segment("bar")) == "foo/bar"); + } + +@safe pure nothrow: + enum defaultSeparator = '/'; + + static bool isSeparator(dchar ch) + @nogc { + return ch == '/'; + } + + static string getAbsolutePrefix(string path) + @nogc { + if (path.length > 0 && path[0] == '/') + return path[0 .. 1]; + return null; + } + + unittest { + assert(getAbsolutePrefix("/") == "/"); + assert(getAbsolutePrefix("/test") == "/"); + assert(getAbsolutePrefix("/test/") == "/"); + assert(getAbsolutePrefix("test/") == ""); + assert(getAbsolutePrefix("") == ""); + assert(getAbsolutePrefix("./") == ""); + } + + static string getFrontNode(string path) + @nogc { + import std.string : indexOf; + auto idx = path.indexOf('/'); + return idx < 0 ? path : path[0 .. idx+1]; + } + + unittest { + assert(getFrontNode("") == ""); + assert(getFrontNode("/bar") == "/"); + assert(getFrontNode("foo/bar") == "foo/"); + assert(getFrontNode("foo/") == "foo/"); + assert(getFrontNode("foo") == "foo"); + } + + static string getBackNode(string path) + @nogc { + import std.string : lastIndexOf; + + if (!path.length) return path; + ptrdiff_t idx; + try idx = path[0 .. $-1].lastIndexOf('/'); + catch (Exception e) assert(false, e.msg); + if (idx >= 0) return path[idx+1 .. $]; + return path; + } + + unittest { + assert(getBackNode("") == ""); + assert(getBackNode("/bar") == "bar"); + assert(getBackNode("foo/bar") == "bar"); + assert(getBackNode("foo/") == "foo/"); + assert(getBackNode("foo") == "foo"); + } + + static string validatePath(string path) + @nogc { + for (size_t i = 0; i < path.length; i++) { + if (isAsciiAlphaNum(path[i])) + continue; + + switch (path[i]) { + default: + return "Invalid character in internet path."; + // unreserved + case '-', '.', '_', '~': + // subdelims + case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': + // additional delims + case ':', '@': + // segment delimiter + case '/': + break; + case '%': // pct encoding + if (path.length < i+3) + return "Unterminated percent encoding sequence in internet path."; + foreach (j; 0 .. 2) { + switch (path[++i]) { + default: return "Invalid percent encoding sequence in internet path."; + case '0': .. case '9': + case 'a': .. case 'f': + case 'A': .. case 'F': + break; + } + } + break; + } + } + return null; + } + + static string validateDecodedSegment(string seg) + @nogc { + return null; + } + + unittest { + assert(validatePath("") is null); + assert(validatePath("/") is null); + assert(validatePath("/test") is null); + assert(validatePath("test") is null); + assert(validatePath("/C:/test") is null); + assert(validatePath("/test%ab") is null); + assert(validatePath("/test%ag") !is null); + assert(validatePath("/test%a") !is null); + assert(validatePath("/test%") !is null); + assert(validatePath("/test§") !is null); + assert(validatePath("föö") !is null); + } + + static auto decodeSingleSegment(string segment) + @nogc { + import std.string : indexOf; + + static int hexDigit(char ch) @safe nothrow @nogc { + assert(ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f'); + if (ch >= '0' && ch <= '9') return ch - '0'; + else if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10; + else return ch - 'A' + 10; + } + + static struct R { + @safe pure nothrow @nogc: + + private { + string m_str; + } + + this(string s) + { + m_str = s; + } + + @property bool empty() const { return m_str.length == 0; } + + @property R save() const { return this; } + + @property char front() + const { + auto ch = m_str[0]; + if (ch != '%') return ch; + + auto a = m_str[1]; + auto b = m_str[2]; + return cast(char)(16 * hexDigit(a) + hexDigit(b)); + } + + @property void popFront() + { + assert(!empty); + if (m_str[0] == '%') m_str = m_str[3 .. $]; + else m_str = m_str[1 .. $]; + } + + @property char back() + const { + if (m_str.length >= 3 && m_str[$-3] == '%') { + auto a = m_str[$-2]; + auto b = m_str[$-1]; + return cast(char)(16 * hexDigit(a) + hexDigit(b)); + } else return m_str[$-1]; + } + + void popBack() + { + assert(!empty); + if (m_str.length >= 3 && m_str[$-3] == '%') m_str = m_str[0 .. $-3]; + else m_str = m_str[0 .. $-1]; + } } + + return R(segment); + } + + unittest { + import std.range : retro; + + scope (failure) assert(false); + + assert(decodeSingleSegment("foo").equal("foo")); + assert(decodeSingleSegment("fo%20o\\").equal("fo o\\")); + assert(decodeSingleSegment("foo%20").equal("foo ")); + assert(decodeSingleSegment("foo").retro.equal("oof")); + assert(decodeSingleSegment("fo%20o\\").retro.equal("\\o of")); + assert(decodeSingleSegment("foo%20").retro.equal(" oof")); + } + + + static string encodeSegment(string segment) + { + import std.array : appender; + + foreach (i, char c; segment) { + if (isAsciiAlphaNum(c)) continue; + switch (c) { + default: + auto ret = appender!string; + ret.put(segment[0 .. i]); + encodeSegment(ret, segment[i .. $]); + return ret.data; + case '-', '.', '_', '~': + case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': + case ':', '@': + break; + } + } + + return segment; + } + + unittest { + assert(encodeSegment("foo") == "foo"); + assert(encodeSegment("foo bar") == "foo%20bar"); + } + + static void encodeSegment(R)(ref R dst, string segment) + { + static immutable char[16] digit = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']; + + foreach (char c; segment) { + switch (c) { + default: + dst.put('%'); + dst.put(digit[uint(c) / 16]); + dst.put(digit[uint(c) % 16]); + break; + case 'a': .. case 'z': + case 'A': .. case 'Z': + case '0': .. case '9': + case '-', '.', '_', '~': + case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=': + case ':', '@': + dst.put(c); + break; + } + } + } +} + +private auto extension(R)(R filename) + if (isForwardRange!R && isSomeChar!(ElementType!R)) +{ + if (filename.empty) return filename; + + static if (isArray!R) { // avoid auto decoding + filename = filename[1 .. $]; // ignore leading dot + + R candidate; + while (filename.length) { + if (filename[0] == '.') + candidate = filename; + filename = filename[1 .. $]; + } + return candidate; + } else { + filename.popFront(); // ignore leading dot + + R candidate; + while (!filename.empty) { + if (filename.front == '.') + candidate = filename.save; + filename.popFront(); + } + return candidate; + } +} + +@safe nothrow unittest { + assert(extension("foo") == ""); + assert(extension("foo.txt") == ".txt"); + assert(extension(".foo") == ""); + assert(extension(".foo.txt") == ".txt"); + assert(extension("foo.bar.txt") == ".txt"); +} + +unittest { + assert(extension(InetPath("foo").head.name).equal("")); + assert(extension(InetPath("foo.txt").head.name).equal(".txt")); + assert(extension(InetPath(".foo").head.name).equal("")); + assert(extension(InetPath(".foo.txt").head.name).equal(".txt")); + assert(extension(InetPath("foo.bar.txt").head.name).equal(".txt")); +} + + +private auto stripExtension(R)(R filename) + if (isForwardRange!R && isSomeChar!(ElementType!R)) +{ + static if (isArray!R) { // make sure to return a slice + if (!filename.length) return filename; + R r = filename; + r = r[1 .. $]; // ignore leading dot + size_t cnt = 0, rcnt = r.length; + while (r.length) { + if (r[0] == '.') + rcnt = cnt; + cnt++; + r = r[1 .. $]; + } + return filename[0 .. rcnt + 1]; + } else { + if (filename.empty) return filename.takeExactly(0); + R r = filename.save; + size_t cnt = 0, rcnt = size_t.max; + r.popFront(); // ignore leading dot + while (!r.empty) { + if (r.front == '.') + rcnt = cnt; + cnt++; + r.popFront(); + } + if (rcnt == size_t.max) return filename.takeExactly(cnt + 1); + return filename.takeExactly(rcnt + 1); } } +@safe nothrow unittest { + assert(stripExtension("foo") == "foo"); + assert(stripExtension("foo.txt") == "foo"); + assert(stripExtension(".foo") == ".foo"); + assert(stripExtension(".foo.txt") == ".foo"); + assert(stripExtension("foo.bar.txt") == "foo.bar"); +} + +unittest { // test range based path + import std.utf : byWchar; + + assert(stripExtension("foo".byWchar).equal("foo")); + assert(stripExtension("foo.txt".byWchar).equal("foo")); + assert(stripExtension(".foo".byWchar).equal(".foo")); + assert(stripExtension(".foo.txt".byWchar).equal(".foo")); + assert(stripExtension("foo.bar.txt".byWchar).equal("foo.bar")); + + assert(stripExtension(InetPath("foo").head.name).equal("foo")); + assert(stripExtension(InetPath("foo.txt").head.name).equal("foo")); + assert(stripExtension(InetPath(".foo").head.name).equal(".foo")); + assert(stripExtension(InetPath(".foo.txt").head.name).equal(".foo")); + assert(stripExtension(InetPath("foo.bar.txt").head.name).equal("foo.bar")); +} + +private static bool isAsciiAlphaNum(char ch) +@safe nothrow pure @nogc { + return (uint(ch) & 0xDF) - 0x41 < 26 || uint(ch) - '0' <= 9; +} + unittest { - assert(NativePath("/foo/bar/baz").relativeTo(NativePath("/foo")).toString == "bar/baz"); - assert(NativePath("/foo/bar/baz/").relativeTo(NativePath("/foo")).toString == "bar/baz/"); - assert(NativePath("/foo/bar").relativeTo(NativePath("/foo")).toString == "bar"); - assert(NativePath("/foo/bar/").relativeTo(NativePath("/foo")).toString == "bar/"); - assert(NativePath("/foo").relativeTo(NativePath("/foo/bar")).toString() == ".."); - assert(NativePath("/foo/").relativeTo(NativePath("/foo/bar")).toString() == "../"); - assert(NativePath("/foo/baz").relativeTo(NativePath("/foo/bar/baz")).toString() == "../../baz"); - assert(NativePath("/foo/baz/").relativeTo(NativePath("/foo/bar/baz")).toString() == "../../baz/"); - assert(NativePath("/foo/").relativeTo(NativePath("/foo/bar/baz")).toString() == "../../"); - assert(NativePath("/foo/").relativeTo(NativePath("/foo/bar/baz/mumpitz")).toString() == "../../../"); - assert(NativePath("/foo").relativeTo(NativePath("/foo")).toString() == ""); - assert(NativePath("/foo/").relativeTo(NativePath("/foo")).toString() == ""); + assert(!isAsciiAlphaNum('@')); + assert(isAsciiAlphaNum('A')); + assert(isAsciiAlphaNum('Z')); + assert(!isAsciiAlphaNum('[')); + assert(!isAsciiAlphaNum('`')); + assert(isAsciiAlphaNum('a')); + assert(isAsciiAlphaNum('z')); + assert(!isAsciiAlphaNum('{')); + assert(!isAsciiAlphaNum('/')); + assert(isAsciiAlphaNum('0')); + assert(isAsciiAlphaNum('9')); + assert(!isAsciiAlphaNum(':')); +} + +unittest { // regression tests + assert(NativePath("").bySegment.empty); } diff --git a/source/dub/internal/vibecompat/inet/url.d b/source/dub/internal/vibecompat/inet/url.d index 34b2ec7d5..38d512875 100644 --- a/source/dub/internal/vibecompat/inet/url.d +++ b/source/dub/internal/vibecompat/inet/url.d @@ -231,9 +231,7 @@ struct URL { } URL opBinary(string OP)(NativePath rhs) const if( OP == "~" ) { return URL(m_schema, m_host, m_port, m_path ~ rhs); } - URL opBinary(string OP)(PathEntry rhs) const if( OP == "~" ) { return URL(m_schema, m_host, m_port, m_path ~ rhs); } void opOpAssign(string OP)(NativePath rhs) if( OP == "~" ) { m_path ~= rhs; } - void opOpAssign(string OP)(PathEntry rhs) if( OP == "~" ) { m_path ~= rhs; } /// Tests two URLs for equality using '=='. bool opEquals(ref const URL rhs) const { @@ -244,13 +242,6 @@ struct URL { } /// ditto bool opEquals(const URL other) const { return opEquals(other); } - - int opCmp(ref const URL rhs) const { - if( m_schema != rhs.m_schema ) return m_schema.cmp(rhs.m_schema); - if( m_host != rhs.m_host ) return m_host.cmp(rhs.m_host); - if( m_path != rhs.m_path ) return m_path.opCmp(rhs.m_path); - return true; - } } unittest { diff --git a/source/dub/packagesuppliers/filesystem.d b/source/dub/packagesuppliers/filesystem.d index ac7a99e7d..d41ecf852 100644 --- a/source/dub/packagesuppliers/filesystem.d +++ b/source/dub/packagesuppliers/filesystem.d @@ -2,6 +2,8 @@ module dub.packagesuppliers.filesystem; import dub.packagesuppliers.packagesupplier; +import dub.internal.vibecompat.inet.path; + /** File system based package supplier.