root/branches/tango/hcf/path.d

/**
 * Helpful path functions
 * 
 * Authors:
 *  Gregor Richards
 * 
 * License:
 *  Copyright (c) 2006  Gregor Richards
 *  
 *  Permission is hereby granted, free of charge, to any person obtaining a
 *  copy of this software and associated documentation files (the "Software"),
 *  to deal in the Software without restriction, including without limitation
 *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
 *  and/or sell copies of the Software, and to permit persons to whom the
 *  Software is furnished to do so, subject to the following conditions:
 *  
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *  
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 *  DEALINGS IN THE SOFTWARE.
 */

module hcf.path;

import tango.io.FileConst;
import tango.io.FilePath;
import tango.io.FileSystem;

import tango.text.String;
import tango.text.Util;

import tango.stdc.stdlib;
import tango.stdc.stringz;

version (Posix) {
    import tango.stdc.posix.sys.stat;
}

version (Windows) {
    import bcd.windows.windows;
}

/* Simple getDirName, etc */
char[] getDirName(char[] fname)
{
    return (new FilePath(fname)).path();
}
char[] getBaseName(char[] fname)
{
    return (new FilePath(fname)).file();
}
char[] getName(char[] fname)
{
    return (new FilePath(fname)).name();
}
char[] getExt(char[] fname)
{
    return (new FilePath(fname)).ext();
}

/** Get the system PATH */
char[][] getPath()
{
    return split(fromUtf8z(getenv("PATH")), FileConst.SystemPathChar~"");
}

/** From args[0], figure out our path.  Returns 'false' on failure */
bool whereAmI(char[] argvz, inout char[] dir, inout char[] bname)
{
    // split it
    bname = getBaseName(argvz);
    dir = getDirName(argvz);
    
    // on Windows, this is a .exe
    version (Windows) {
        bname = defaultExt(bname, "exe");
    }
    
    // is this a directory?
    if (dir != "") {
        if (!(new FilePath(dir)).isAbsolute()) {
            // make it absolute
            dir = FileSystem.getDirectory() ~ FileConst.PathSeparatorChar ~ dir;
        }
        return true;
    }
    
    version (Windows) {
        // is it in cwd?
        char[] cwd = FileSystem.getDirectory();
        if ((new FilePath(cwd ~ FileConst.PathSeparatorChar ~ bname)).exists()) {
            dir = cwd;
            return true;
        }
    }
    
    // rifle through the path
    char[][] path = getPath();
    foreach (pe; path) {
        char[] fullname = pe ~ FileConst.PathSeparatorChar ~ bname;
        if ((new FilePath(fullname)).exists()) {
            //version (Windows) {
                dir = pe;
                return true;
            /*} else {
                stat_t stats;
                stat(toUtf8z(fullname), &stats);
                if ((cast(int) stats) & 0100) {
                    dir = pe;
                    return true;
                }
            }*/
        }
    }
    
    // bad
    return false;
}

/// Return a canonical pathname
char[] canonPath(char[] origpath)
{
    char[] ret;
    
    version (Windows) {
        // replace any altsep with sep
        if (altsep.length) {
            ret = replace(origpath, altsep, sep);
        } else {
            ret = origpath.dup;
        }
    } else {
        ret = origpath.dup;
    }
    
    // expand tildes
    // ret = expandTilde(ret); FIXME
    
    // get rid of any duplicate separators
    for (int i = 0; i < ret.length; i++) {
        if (ret[i .. (i + 1)] == FileConst.PathSeparatorChar~"") {
            // drop the duplicate separator
            i++;
            while (i < ret.length &&
                   ret[i .. (i + 1)] == FileConst.PathSeparatorChar~"") {
                ret = ret[0 .. i] ~ ret[(i + 1) .. $];
            }
        }
    }
    
    // make sure we don't miss a .. element
    if (ret.length > 3 && ret[($-3) .. $] == FileConst.PathSeparatorChar ~ "..") {
        ret ~= FileConst.PathSeparatorChar;
    }
    
    // or a . element
    if (ret.length > 2 && ret[($-2) .. $] == FileConst.PathSeparatorChar ~ ".") {
        ret ~= FileConst.PathSeparatorChar;
    }
    
    // search for .. elements
    for (int i = 0; ret.length > 4 && i <= ret.length - 4; i++) {
        if (ret[i .. (i + 4)] == FileConst.PathSeparatorChar ~ ".." ~ FileConst.PathSeparatorChar) {
            // drop the previous path element
            int j;
            for (j = i - 1; j > 0 && ret[j..(j+1)] != FileConst.PathSeparatorChar~""; j--) {}
            if (j > 0) {
                // cut
                ret = ret[0..j] ~ ret[(i + 3) .. $];
            } else {
                // sort of ridiculous, but cut as best we can
                ret = FileConst.PathSeparatorChar ~ ret[(i + 3) .. $];
            }
            i = j - 1;
        }
    }
    
    // search for . elements
    for (int i = 0; ret.length > 2 && i <= ret.length - 3; i++) {
        if (ret[i .. (i + 3)] == FileConst.PathSeparatorChar ~ "." ~ FileConst.PathSeparatorChar) {
            // drop this path element
            ret = ret[0..i] ~ ret[(i + 2) .. $];
            i--;
        }
    }

    // get rid of any introductory ./'s
    while (ret.length > 2 && ret[0..2] == "." ~ FileConst.PathSeparatorChar) {
        ret = ret[2..$];
    }
    
    // finally, get rid of any trailing separators
    while (ret.length &&
           ret[($ - 1) .. $] == FileConst.PathSeparatorChar~"") {
        ret = ret[0 .. ($ - 1)];
    }
    
    return ret;
}

/** Make a directory and all parent directories */
void mkdirP(char[] dir)
{
    dir = canonPath(dir);
    version (Windows) {
        dir = std.string.replace(dir, "/", "\\");
    }
    
    // split it into elements
    char[][] dires = split(dir, FileConst.PathSeparatorChar~"");
    
    char[] curdir;
    
    // check for root dir
    if (dires.length &&
        dires[0] == "") {
        curdir = FileConst.PathSeparatorChar~"";
        dires = dires[1..$];
    }
    
    // then go piece-by-piece, making directories
    foreach (dire; dires) {
        if (curdir.length) {
            curdir ~= FileConst.PathSeparatorChar ~ dire;
        } else {
            curdir ~= dire;
        }
        
        if (!(new FilePath(curdir)).exists()) {
            (new FilePath(curdir)).createFolder();
        }
    }
}

/** Remove a file or directory and all of its children */
void rmRecursive(char[] name)
{
    // can only delete writable files on Windows
    version (Windows) {
        SetFileAttributesA(toUtf8z(name),
                           GetFileAttributesA(toUtf8z(name)) &
                           ~FILE_ATTRIBUTE_READONLY);
    }
    
    if ((new FilePath(name)).isFolder()) {
        foreach (elem; (new FilePath(name)).toList((FilePath path, bool isFolder) { return true; })) {
            // don't delete . or ..
            if (elem.name == "." ||
                elem.name == "..") continue;
            rmRecursive(name ~ FileConst.PathSeparatorChar ~ elem.name);
        }
        
        // remove the directory itself
        (new FilePath(name)).remove();
    } else {
        (new FilePath(name)).remove();
    }
}