dubmore: Support of local and remote archive dependencies

[Andre Pany via Digitalmars-d-announce]

Hi,

I want to share with you a little application I wrote. With the 
following application you can add local and remote archive 
dependencies to your dub configuration.

/+ dub.json:
{
        "name":"test"
        "dependencies":{
                "sample1":{"path":"C:\\D\\projects\\test2\\sample1.zip",
                "sample2":{"url":"http://localhost:8080/sample2.zip";
        },
}
+/

void main() {}

Place the dubmore executable into the same folder as dub and use 
dubmore instead of dub.

Remarks:
- Only json is supported
- You need to have the console application unzip in your system 
path

--
module dubmore;
import std.file, std.path, std.exception, std.process, std.array, 
std.json, std.net.curl, std.experimental.logger, std.algorithm, 
std.getopt, std.string;

void main(string[] args)
{
        globalLogLevel = LogLevel.all;
        string dubFile;
	scope(exit) if (exists(dubFile~".old")) rename(dubFile~".old", 
dubFile);
        string[] dubArgs;
        
        string packagesFolder = buildPath(getcwd(), "packages");
	if (args.canFind("--force") && exists(packagesFolder)) 
rmdirRecurse(packagesFolder);
        if (!exists(packagesFolder)) mkdir(packagesFolder);
        
        if (exists(buildPath(getcwd(), "dub.json")))
        {
                dubFile = buildPath(getcwd(), "dub.json");
                dubArgs = args[1..$];
                auto jsRoot = parseJSON(readText(dubFile));
                if (processJson(jsRoot, packagesFolder))
                {
                        copy(dubFile, dubFile~".old");
                        writeTextFile(dubFile, jsRoot.toString);
                }
        }
	else if (args.length > 1 && buildPath(getcwd(), 
args[1].stripExtension~".d").exists)
        {
                enum marker = "dub.json:";
                dubFile = buildPath(getcwd(), args[1].stripExtension~".d");
                dubArgs = dubFile~args[2..$];
                string sourceCode = readText(dubFile);
                auto startPos = sourceCode.indexOf("/+");
                auto markerPos = sourceCode.indexOf(marker);
                auto endPos =  sourceCode.indexOf("+/");
                if (startPos > -1 && markerPos > startPos && markerPos < endPos)
                {
			auto jsRoot = 
parseJSON(sourceCode[markerPos+marker.length..endPos]);
                        if (processJson(jsRoot, packagesFolder))
                        {
				sourceCode = sourceCode[0..markerPos+marker.length]~" 
"~jsRoot.toString~" "~sourceCode[endPos..$];
                                copy(dubFile, dubFile~".old");
                                writeTextFile(dubFile, sourceCode);
                        }
                }
        }
        import std.stdio: writeln;
        with (execute(["dub"]~dubArgs)) writeln(output);
}

private bool processJson(JSONValue jsRoot, string packagesFolder)
{
        bool found = processDependencies(jsRoot, packagesFolder);
	if ("configurations" in jsRoot && jsRoot["configurations"].type 
== JSON_TYPE.ARRAY)
			found = jsRoot["configurations"].array.any!(jsConfig => 
processDependencies(jsConfig, packagesFolder)) || found;
        return found;
}

private bool processDependencies(JSONValue js, string 
packagesFolder)
{
        bool result;
	if ("dependencies" in js && js["dependencies"].type == 
JSON_TYPE.OBJECT)
        {
                foreach(key; js["dependencies"].object.keys)
                {
                        auto dep = js["dependencies"].object[key];
			if (dep.type == JSON_TYPE.OBJECT && "url" in dep && 
dep["url"].type == JSON_TYPE.STRING)
                        {
                                string url = dep["url"].str;
                                string fileName = url.split("/").array[$-1];
                                string destination = buildPath(packagesFolder, 
fileName);
                                
                                if (exists(destination))
                                {
					dep["path"] = buildPath(destination.dirName, 
destination.stripExtension);
                                }
                                else
                                {
                                        try     { dep["path"] = 
downloadAndExtract(url, destination); }
                                        catch(Exception e)
                                        {
                                                error(e.msg);
                                                continue;
                                        }
                                }
                                dep.object.remove("url");
                                result = true;
                        }
			else if (dep.type == JSON_TYPE.OBJECT && "path" in dep && 
dep["path"].type == JSON_TYPE.STRING && 
dep["path"].str.toLower.endsWith(".zip"))
                        {
                                string filePath = dep["path"].str;
				string packageFolder = buildPath(packagesFolder, 
filePath.baseName.stripExtension);

                                if (!exists(packageFolder))
					with (execute(["unzip", "-o", filePath, "-d", 
packagesFolder])) enforce(status == 0, output);

                                dep["path"] = packageFolder;  
                                result = true;
                        }
                }
        }
        return result;
}

private string downloadAndExtract(string url, string destination)
{
        info("download: ", url, " to ", destination);
        download(url, destination);
	enforce(destination.toLower.endsWith(".zip"), "Unknown file 
extenstion");
	with (execute(["unzip", destination, "-d", 
destination.dirName])) enforce(status == 0, output);
	return buildPath(destination.dirName, 
destination.baseName!(std.path.CaseSensitive.no)(".zip"));
}

private void writeTextFile(string filePath, string content)
{
        import std.stdio: File;
        auto f = File(filePath, "wb");
        f.write(content);
    f.close();
}

--

Kind regards
André