Changeset 1692

Timestamp:

06/24/10 01:14:06 (14 years ago)

Author:

rsinfu

Message:

- Fixed bugzilla 3937: os.path.dirname fails on absolute path.
- Fixed bugzilla 4260: windows & basename.
- Made dirname() tolerant of excess path separators (e.g. "/usr//src").
- Fixed dirname() to deal with Windows' "current directory of a drive" case (e.g. "C:.").
- Made basename() more generic.
- Added more unittests for dirname() and basename().
- Changed version(Win32) to version(Windows) as the module doesn't depend on pointer size.
- Added guard assertion for unknown platforms.

Files:

• trunk/docsrc/changelog.dd (modified) (1 diff)
• trunk/phobos/std/path.d (modified) (13 diffs)

trunk/docsrc/changelog.dd

@@ -13 +13 @@
-    $(LI $(BUGZILLA 978): std.utf's toUTF* functions accept some invalid and reject some valid UTF)
-    $(LI $(BUGZILLA 996): Error in doc on implicit conversion between pointer and array)
-    $(LI $(BUGZILLA 2275): std.utf.toUTF16z() should return const(wchar)*)
-    $(LI $(BUGZILLA 2872): Length, opIndex for Map)
-    $(LI $(BUGZILLA 3202): std.math.pow cause dead loop)
-    $(LI $(BUGZILLA 3355): std.string.cmp works incorrectly for mixed-type and different-length strings)
-    $(LI $(BUGZILLA 3386): to!bool(string) is not implemented)
-    $(LI $(BUGZILLA 3436): std.functional.compose with only one function)
-    $(LI $(BUGZILLA 3439): std.range.Sequence.opIndex not consistent after calling popFront().)
-    $(LI $(BUGZILLA 3447): std.file uses unconventional file permissions)
+    $(LI $(BUGZILLA 3937): os.path.dirname fails on absolute path)
-    $(LI $(BUGZILLA 3961): Error with to!(somestruct))
-    $(LI $(BUGZILLA 4109): (reopened) writeln doesn't work with empty static array)
-    $(LI $(BUGZILLA 4171): std.random.uniform does not work for a range of characters)
+    $(LI $(BUGZILLA 4260): windows & basename)
-    $(LI $(BUGZILLA 4327): std.container.Array.Range.~this() tries to call free(T[]))
-    $(LI $(BUGZILLA 4362): std.range.repeat and cycle do not have a .save() method
-    $(LI $(BUGZILLA 4363): std.algorithm.Until is not a forward range)
-    )
-)
-
-<div id=version>
-$(UL
-    $(NEW 048)
-    $(NEW 047)

trunk/phobos/std/path.d

@@ -20 +20 @@
- *          Copyright Digital Mars 2000 - 2009.
- * Distributed under the Boost Software License, Version 1.0.
- *    (See accompanying file LICENSE_1_0.txt or copy at
- *          http://www.boost.org/LICENSE_1_0.txt)
- */
-module std.path;
-
-//debug=path;       // uncomment to turn on debugging printf's
-//private import std.stdio;
-
-contracts
+array
-import core.stdc.errno, core.stdc.stdlib;
-
-version(Posix)
-{
-    private import core.sys.posix.pwd;
-    private import core.exception : onOutOfMemoryError;
-}
-
-version(Windows)
-{
@@ -95 +95 @@
- * also terminates the search.
- *
- * Returns: If a dot was found, characters to its right are
- * returned. If a path separator was found, or fullname didn't
- * contain any dots or path separators, returns null.
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     getExt(r"d:\path\foo.bat") // "bat"
- *     getExt(r"d:\path.two\bar") // null
- * }
- * version(Posix)
- * {
- *     getExt(r"/home/user.name/bar.")  // ""
- *     getExt(r"d:\\path.two\\bar")     // "two\\bar"
- *     getExt(r"/home/user/.resource")  // "resource"
- * }
- * -----
- */
-
-string getExt(string fullname)
-{
-    auto i = fullname.length;
-    while (i > 0)
-    {
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-    return null;
-}
-
-unittest
-{
-    debug(path) printf("path.getExt.unittest\n");
-    string result;
-
-32
+dows
-    result = getExt("d:\\path\\foo.bat");
-    version (Posix)
-    result = getExt("/path/foo.bat");
-    auto i = cmp(result, "bat");
-    assert(i == 0);
-
-32
+dows
-    result = getExt("d:\\path\\foo.");
-    version (Posix)
-    result = getExt("d/path/foo.");
-    i = cmp(result, "");
-    assert(i == 0);
-
-32
+dows
-    result = getExt("d:\\path\\foo");
-    version (Posix)
-    result = getExt("d/path/foo");
-    i = cmp(result, "");
-    assert(i == 0);
-
-32
+dows
-    result = getExt("d:\\path.bar\\foo");
-    version (Posix)
-    result = getExt("/path.bar/foo");
-
-    i = cmp(result, "");
-    assert(i == 0);
-
-    result = getExt("foo");
-    i = cmp(result, "");
-    assert(i == 0);
@@ -186 +190 @@
- * also terminates the search.
- *
- * Returns: If a dot was found, characters to its left are
- * returned. If a path separator was found, or fullname didn't
- * contain any dots or path separators, returns null.
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     getName(r"d:\path\foo.bat") => "d:\path\foo"
- *     getName(r"d:\path.two\bar") => null
- * }
- * version(Posix)
- * {
- *     getName("/home/user.name/bar.")  => "/home/user.name/bar"
- *     getName(r"d:\path.two\bar") => "d:\path"
- *     getName("/home/user/.resource") => "/home/user/"
- * }
- * -----
- */
-
-string getName(string fullname)
-{
-    auto i = fullname.length;
-    while (i > 0)
-    {
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-    return null;
-}
-
-unittest
-{
-    debug(path) printf("path.getName.unittest\n");
-    string result;
-
-    result = getName("foo.bar");
-    auto i = cmp(result, "foo");
-    assert(i == 0);
-
-    result = getName("d:\\path.two\\bar");
-32
+dows
-    i = cmp(result, "");
-    version (Posix)
-    i = cmp(result, "d:\\path");
-    assert(i == 0);
-}
-
-/**************************
- * Extracts the base name of a path and optionally chops off a
- * specific suffix.
- *
@@ -258 +266 @@
- * $(D_PARAM fullname) otherwise. If the kept portion has suffix
- * $(D_PARAM extension), remove that suffix. Return the remaining string.
- *
- * Returns: The portion of $(D_PARAM fullname) left after the path
- * part and the extension part, if any, have been removed.
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     basename(r"d:\path\foo.bat") => "foo.bat"
- *     basename(r"d:\path\foo", ".bat") => "foo"
- * }
- * version(Posix)
- * {
- *     basename("/home/user.name/bar.")  => "bar."
- *     basename("/home/user.name/bar.", ".")  => "bar"
- * }
- * -----
- */
-
-
+
+
-out (result)
-{
-    assert(result.length <= fullname.length);
-}
-body
-{
-   
-   
-   
-       version(Win32
-   
-
+    
+    
+    
+        version(Windows
+    
+ || fullname[i - 1] == '/'
-                break;
-   
-      
-   
+    
+        else
+    
-            if (fullname[i - 1] == '/')
-                break;
-
-
-
-
+
+
+
+
+
+
+
+
-}
-
-/** Alias for $(D_PARAM basename), kept for backward
- * compatibility. New code should use $(D_PARAM basename). */
-alias basename getBaseName;
-
-unittest
-{
-    debug(path) printf("path.basename.unittest\n");
-    string result;
@@ -324 +337 @@
-    version (Posix)
-    result = basename("a/b");
-    assert(result == "b");
-
-    version (Windows)
-    result = basename("a\\b.cde", ".cde");
-    version (Posix)
-    result = basename("a/b.cde", ".cde");
-    assert(result == "b");
-
+    version (Windows)
+    {
+        assert(basename("abc/xyz") == "xyz");
+        assert(basename("abc/") == "");
+        assert(basename("C:/a/b") == "b");
+        assert(basename(`C:\a/b`) == "b");
+    }
+
+    assert(basename("~/dmd.conf"w, ".conf"d) == "dmd");
+    assert(basename("~/dmd.conf"d, ".conf"d) == "dmd");
+    assert(basename("dmd.conf"w.dup, ".conf"d.dup) == "dmd");
-}
-
-/**************************
- * Extracts the directory part of a path.
- *
- * This function will search $(D fullname) from the end until the
- * first path separator or first character of $(D fullname) is
- * reached. Under Windows, the drive letter separator ($(I colon))
- * also terminates the search.
- *
- * Returns: If a path separator was found, all the characters to its
-
-
-
-
+
+
+
+
+
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     assert(dirname(r"d:\path\foo.bat") == r"d:\path");
-
+
+
+
- * }
- * version(Posix)
- * {
- *     assert(dirname("/home/user") == "/home");
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                break;
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            {
-
-
-
-
-
+
-                break;
-            }
-        }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                break;
-            }
-        }
-
-
+
+
+
+
+
+
-}
-
-unittest
-{
-    assert(dirname("") == ".");
-    assert(dirname("fileonly") == ".");
+
-    version (Posix)
-    {
-        assert(dirname("/path/to/file") == "/path/to");
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}
-
-/** Alias for $(D_PARAM dirname), kept for backward
- * compatibility. New code should use $(D_PARAM dirname). */
-alias dirname getDirName;
-
-unittest
-{
-    string filename = "foo/bar";
-    auto d = getDirName(filename);
-    assert(d == "foo");
-}
+
+unittest // dirname + basename
+{
+    static immutable Common_dirbasename_testcases =
+    [
+        [ "/usr/lib"  , "/usr"   , "lib"    ],
+        [ "/usr/"     , "/usr"   , ""       ],
+        [ "/usr"      , "/"      , "usr"    ],
+        [ "/"         , "/"      , ""       ],
+
+        [ "var/run"   , "var"    , "run"    ],
+        [ "var/"      , "var"    , ""       ],
+        [ "var"       , "."      , "var"    ],
+        [ "."         , "."      , "."      ],
+
+        [ "/usr///lib", "/usr"   , "lib"    ],
+        [ "///usr///" , "///usr" , ""       ],
+        [ "///usr"    , "/"      , "usr"    ],
+        [ "///"       , "/"      , ""       ],
+        [ "var///run" , "var"    , "run"    ],
+        [ "var///"    , "var"    , ""       ],
+
+        [ "a/b/c"     , "a/b"    , "c"      ],
+        [ "a///c"     , "a"      , "c"      ],
+        [ "/\u7A74"   , "/"      , "\u7A74" ],
+        [ "/\u7A74/." , "/\u7A74", "."      ]
+    ];
+
+    static immutable Windows_dirbasename_testcases =
+        Common_dirbasename_testcases ~
+    [
+        [ "C:\\Users\\7mi", "C:\\Users", "7mi"   ],
+        [ "C:\\Users\\"   , "C:\\Users", ""      ],
+        [ "C:\\Users"     , "C:\\"     , "Users" ],
+        [ "C:\\"          , "C:\\"     , ""      ],
+
+        [ "C:Temp"        , "C:."      , "Temp"  ],
+        [ "C:"            , "C:."      , ""      ],
+        [ "\\dmd\\src"    , "\\dmd"    , "src"   ],
+        [ "\\dmd\\"       , "\\dmd"    , ""      ],
+        [ "\\dmd"         , "\\"       , "dmd"   ],
+
+        [ "C:/Users/7mi"  , "C:/Users" , "7mi"   ],
+        [ "C:/Users/"     , "C:/Users" , ""      ],
+        [ "C:/Users"      , "C:/"      , "Users" ],
+        [ "C:/"           , "C:/"      , ""      ],
+
+        [ "C:\\//WinNT"   , "C:\\"     , "WinNT" ],
+        [ "C://\\WinNT"   , "C:/"      , "WinNT" ],
+
+        [ `a\b\c`         , `a\b`      , "c"     ],
+        [ `a\\\c`         , "a"        , "c"     ]
+    ];
+
+    version (Windows)
+        alias Windows_dirbasename_testcases testcases;
+    else
+        alias Common_dirbasename_testcases testcases;
+
+    foreach (tc; testcases)
+    {
+        string path = tc[0];
+        string dir  = tc[1];
+        string base = tc[2];
+
+        assert(path.dirname == dir);
+        assert(path.basename == base);
+    }
+}
+
-
-/********************************
- * Extracts the drive letter of a path.
- *
- * This function will search fullname for a colon from the beginning.
- *
- * Returns: If a colon is found, all the characters to its left
- * plus the colon are returned.  Otherwise, null is returned.
- *
- * Under Linux, this function always returns null immediately.
@@ -443 +595 @@
- */
-
-String getDrive(String)(String fullname) if (isSomeString!(String))
-// @@@ BUG 2799
-// out(result)
-// {
-//     assert(result.length <= fullname.length);
-// }
-body
-{
-   version(Win32
-   
-   
-   
+    version(Windows
+    
+    
+    
-            if (fullname[i] == ':')
-                return fullname[0 .. i + 1];
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-}
-
-/****************************
- * Appends a default extension to a filename.
- *
- * This function first searches filename for an extension and
- * appends ext if there is none. ext should not have any leading
- * dots, one will be inserted between filename and ext if filename
- * doesn't already end with one.
- *
@@ -551 +707 @@
- * Checks if path is absolute.
- *
- * Returns: non-zero if the path starts from the root directory (Linux) or
- * drive letter and root directory (Windows),
- * zero otherwise.
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     isabs(r"relative\path") => 0
- *     isabs(r"\relative\path") => 0
- *     isabs(r"d:\absolute") => 1
- * }
- * version(Posix)
- * {
- *     isabs("/home/user") => 1
- *     isabs("foo") => 0
- * }
- * -----
- */
-
-bool isabs(in char[] path)
-{
-    auto d = getDrive(path);
-    version (Windows)
-    {
-
-
+
+
+
+
+
+
-    }
-    else
-
+
+
+
-}
-
-unittest
-{
-    debug(path) printf("path.isabs.unittest\n");
-
-    version (Windows)
-    {
-    assert(!isabs(r"relative\path"));
-    assert(isabs(r"\relative\path"));
@@ -647 +809 @@
- * If p1 doesn't have a trailing path separator, one will be appended
- * to it before concatenating p2.
- *
- * Returns: p1 ~ p2. However, if p2 is an absolute path, only p2
- * will be returned.
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     join(r"c:\foo", "bar") => r"c:\foo\bar"
- *     join("foo", r"d:\bar") => r"d:\bar"
- * }
- * version(Posix)
- * {
- *     join("/foo/", "bar") => "/foo/bar"
- *     join("/foo", "/bar") => "/bar"
- * }
- * -----
@@ -677 +839 @@
-    // Focus on exactly two components
-    version (Posix)
-    {
-        if (isabs(p2)) return p2.idup;
-        if (p1.endsWith(sep[]) || altsep.length && p1.endsWith(altsep[]))
-        {
-            return cast(string) (p1 ~ p2);
-        }
-        return cast(string) (p1 ~ sep ~ p2);
-    }
-
+else 
-    { 
-        if (!p2.length)
-            return p1.idup;
-        if (!p1.length)
-            return p2.idup;
-
-        string p;
-        const(char)[] d1;
-
-        if (getDrive(p2))
@@ -718 +880 @@
-            {
-                p = cast(string) (p1 ~ p2);
-            }
-            else
-            {
-                p = cast(string)(p1 ~ sep ~ p2);
-            }
-        }
-        return p;
-    }
+    else // unknown platform
+    {
+        static assert(0);
+    }
-}
-
-unittest
-{
-    debug(path) printf("path.join.unittest\n");
-
-    string p;
-    int i;
-
-    p = join("foo", "bar");
-32
+dows
-    i = cmp(p, "foo\\bar");
-    version (Posix)
-    i = cmp(p, "foo/bar");
-    assert(i == 0);
-
-32
+dows
-    {   p = join("foo\\", "bar");
-    i = cmp(p, "foo\\bar");
-    }
-    version (Posix)
-    {   p = join("foo/", "bar");
-    i = cmp(p, "foo/bar");
-    }
-    assert(i == 0);
-
-32
+dows
-    {   p = join("foo", "\\bar");
-    i = cmp(p, "\\bar");
-    }
-    version (Posix)
-    {   p = join("foo", "/bar");
-    i = cmp(p, "/bar");
-    }
-    assert(i == 0);
-
-32
+dows
-    {   p = join("foo\\", "\\bar");
-    i = cmp(p, "\\bar");
-    }
-    version (Posix)
-    {   p = join("foo/", "/bar");
-    i = cmp(p, "/bar");
-    }
-    assert(i == 0);
-
-32
+dows
-    {
-        p = join("d:", "bar");
-        i = cmp(p, "d:bar");
-        assert(i == 0);
-        
-        p = join("d:\\", "bar");
-        i = cmp(p, "d:\\bar");
-        assert(i == 0);
-
-        p = join("d:\\", "\\bar");
@@ -815 +981 @@
- *
- * Under Windows, the comparison is done ignoring case. Under Linux
- * an exact match is performed.
- *
- * Returns: non zero if c1 matches c2, zero otherwise.
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     fncharmatch('a', 'b') => 0
- *     fncharmatch('A', 'a') => 1
- * }
- * version(Posix)
- * {
- *     fncharmatch('a', 'b') => 0
- *     fncharmatch('A', 'a') => 0
- * }
- * -----
- */
-
-bool fncharmatch(dchar c1, dchar c2)
-{
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}
-
-/************************************
- * Matches a pattern against a filename.
- *
- * Some characters of pattern have special a meaning (they are
- * <i>meta-characters</i>) and <b>can't</b> be escaped. These are:
- * <p><table>
- * <tr><td><b>*</b></td>
@@ -878 +1048 @@
- * further portions of the filename.
- *
- * Returns: non zero if pattern matches filename, zero otherwise.
- *
- * See_Also: fncharmatch().
- *
- * Throws: Nothing.
- *
- * Examples:
- * -----
-32
+dows
- * {
- *     fnmatch("foo.bar", "*") => 1
- *     fnmatch(r"foo/foo\bar", "f*b*r") => 1
- *     fnmatch("foo.bar", "f?bar") => 0
- *     fnmatch("Goo.bar", "[fg]???bar") => 1
- *     fnmatch(r"d:\foo\bar", "d*foo?bar") => 1
- * }
- * version(Posix)
- * {
- *     fnmatch("Go*.bar", "[fg]???bar") => 0
@@ -989 +1159 @@
-            break;
-        }
-    }
-    return ni >= filename.length;
-    }
-
-unittest
-{
-    debug(path) printf("path.fnmatch.unittest\n");
-
-32
+dows
-    assert(fnmatch("foo", "Foo"));
-    version (Posix)
-    assert(!fnmatch("foo", "Foo"));
-    assert(fnmatch("foo", "*"));
-    assert(fnmatch("foo.bar", "*"));
-    assert(fnmatch("foo.bar", "*.*"));
-    assert(fnmatch("foo.bar", "foo*"));
-    assert(fnmatch("foo.bar", "f*bar"));
-    assert(fnmatch("foo.bar", "f*b*r"));
-    assert(fnmatch("foo.bar", "f???bar"));