root/trunk/install.d

/*
    IMPORTANT: This script currently does not copy any library files anywhere.
    It only copies the source tree to the directory specified on the command line.
    All modules will be flattened into a <install_path>/derelict directory.
    
    Untested on linux!
*/
/*
 * Copyright (c) 2004-2008 Derelict Developers
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the names 'Derelict' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

version(Tango)
{
    static assert(0, "This script does not support Tango");
}

import std.stdio;
import std.path;
import std.file;
import std.string;
import std.c.process;

version(Windows)
{
    private static const char[] mkdir   = "mkdir ";
    private static const char[] copyCmd = "@copy /Y ";
}
else version(linux)
{
    private static const char[] mkdir   = "mkdir ";
    private static const char[] copyCmd = "cp ";
}
else
{
    static assert(0, "Unsupported Operating System.");
}

void main(char[][] args)
{
    if(args.length < 2)
    {
        writefln("Usage: dmd -run install.d <install_path>");
        return;
    }
    
    char[] installPath = args[1];
    if(!exists(installPath))
    {
        throw new Error("Path [" ~ installPath ~ " does not exist.");
    }
    
    auto iderelict = std.path.join(installPath, "derelict");
    if(!exists(iderelict))
    {
        execute(mkdir ~ iderelict);
    }
    
    if(args.length > 2)
    {
        for(int i=2; i<args.length; ++i)
        {
            auto derelict = std.path.join(args[i], "derelict");
            if(exists(derelict))
            {
                process(derelict, iderelict, "");
            }
        }
    }
    else
    {
        char[][] dirList = listdir(".");
        foreach(d; dirList)
        {
            if(d[0] == '.' || !isdir(d)) continue;
            auto derelict = std.path.join(d, "derelict");
            if(exists(derelict))
            {
                process(derelict, iderelict, "");
            }
        }
    }
}

void process(char[] path, char[] root, char[] dir)
{
    //writefln("Processing %s, %s, %s", path, root, dir);
    char[] ipath = std.path.join(root, dir);
    if(!exists(ipath))
    {
        //writefln("Create dir %s", ipath);
        execute(mkdir ~ ipath);
    }
    
    char[][] dirList = listdir(path);
    foreach(d; dirList)
    {
        if(d[0] == '.') continue;
        auto fullpath = std.path.join(path, d);
        if(isdir(fullpath))
        {
            process(fullpath, ipath, d);
        }
        else
        {
            auto dst = std.path.join(ipath, d);
            execute(copyCmd ~ fullpath ~ " " ~ dst);
            //writefln("Copy %s to %s", fullpath, dst);         
        }
    }
}

void execute(char[] cmd)
{
    system(toStringz(cmd));
}