Update:

- Improved error messages
- Performance on the environment parsing (no useless lock)
- Improved warning for when running redub

Author: MrcSnm

source/app.d

@@ -119,16 +119,16 @@ int runMain(string[] args, string[] runArgs)
     ProjectDetails d = resolveDependencies(args);
     if(!d.tree || d.usesExternalErrorCode)
         return d.getReturnCode;
+    if(d.tree.name == "redub")
+        warnTitle("Attempt to build and run redub with redub: ", "For building redub with redub, use the command 'redub update' which already outputs an optimized build");
     d = buildProject(d);
     if(!d.tree || d.usesExternalErrorCode)
         return d.getReturnCode;
     if(d.tree.requirements.cfg.targetType != TargetType.executable)
         return 1;
+    
     if(d.tree.name == "redub")
-    {
-        warnTitle("Attempt to build and run redub with redub: ", "For building redub with redub, use the command 'redub update' which already outputs an optimized build");
         return 0;
-    }
     return executeProgram(d.tree, runArgs);
 }
 

source/redub/package_searching/downloader.d

@@ -37,7 +37,8 @@ string getDownloadLink(string packageName, string repo, SemVer requirement, out
     if(requirement.isInvalid)
     {
         if(!repo)
-            throw new Exception("Can't have invalid requirement '"~requirement.toString~"' and have no 'repo' information.");
+            throw new Exception("Can't have invalid requirement '"~requirement.toString~"' and have no 'repository' information.
+            \nExample of repository with branch usage: \"redub\": {\"version\": \"~master\", \"repository\": \"git+https://github.com/MrcSnm/redub.git\"}");
         actualVer = requirement;
         return getGitDownloadLink(packageName, repo, requirement.toString);
     }

source/redub/parsers/base.d

@@ -71,28 +71,34 @@ void addExtraDependencyFiles(ref BuildRequirements req, JSONStringArray files, P
 void addFilesToCopy(ref BuildRequirements req, JSONStringArray files, ParseConfig c){req.cfg.filesToCopy = req.cfg.filesToCopy.append(files);}
 void addPreGenerateCommands(ref BuildRequirements req, JSONStringArray cmds, ParseConfig c)
 {
-    import hipjson;
+    if(req.cfg.commands.length <= RedubCommands.preGenerate)
+        req.cfg.commands.length = RedubCommands.preGenerate + 1;
+    req.cfg.commands[RedubCommands.preGenerate] = req.cfg.commands[RedubCommands.preGenerate].append(cmds);
+}
+
+void runPreGenerateCommands(ParseConfig c, ref BuildRequirements req)
+{
+    import redub.parsers.environment;
+    string[string] outRedubEnv;
+    req.cfg = parseEnvironmentForPreGenerate(req.cfg, outRedubEnv);
     import redub.parsers.environment;
     if(c.preGenerateRun)
     {
         infos("Pre-gen ", "Running commands for ", c.extra.requiredBy);
-        foreach(JSONValue cmd; cmds.save)
+        foreach(string cmd; req.cfg.preGenerateCommands)
         {
             import std.process;
             import std.stdio;
             import std.conv:to;
 
             if(hasLogLevel(LogLevel.verbose))
-                vlog("Executing: ", executeShell("echo "~cmd.str, getRedubEnv, Config.none, size_t.max, c.workingDir).output, " at dir ", c.workingDir);
+                vlog("Executing: ", executeShell("echo "~cmd, outRedubEnv, Config.none, size_t.max, c.workingDir).output, " at dir ", c.workingDir);
 
-            auto status = wait(spawnShell(cmd.str, stdin, stdout, stderr, getRedubEnv, Config.none, c.workingDir));
+            auto status = wait(spawnShell(cmd, stdin, stdout, stderr, outRedubEnv, Config.none, c.workingDir));
             if(status)
-                throw new Exception("preGenerateCommand '"~cmd.str~"' exited with code "~status.to!string);
+                throw new Exception("preGenerateCommand '"~cmd~"' exited with code "~status.to!string);
         }
     }
-    if(req.cfg.commands.length <= RedubCommands.preGenerate)
-        req.cfg.commands.length = RedubCommands.preGenerate + 1;
-    req.cfg.commands[RedubCommands.preGenerate] = req.cfg.commands[RedubCommands.preGenerate].append(cmds);
 }
 void addPostGenerateCommands(ref BuildRequirements req, JSONStringArray cmds, ParseConfig c)
 {

source/redub/parsers/environment.d

@@ -191,7 +191,7 @@ void setupEnvironmentVariablesForPackageTree(ProjectNode root)
     ///Path to a specific package that is part of the package's dependency graph. $ must be in uppercase letters without the semver string.
     // <PKG>_PACKAGE_DIR ;
     foreach(ProjectNode mem; root.collapse)
-        setEnvVariable(asPackageVariable(mem.name)~"_PACKAGE_DIR",  mem.requirements.cfg.workingDir.forceTrailingDirSeparator);
+        setEnvVariableNoLock(asPackageVariable(mem.name)~"_PACKAGE_DIR",  mem.requirements.cfg.workingDir.forceTrailingDirSeparator);
 }
 
 /** 
@@ -226,14 +226,12 @@ PackageDubVariables getEnvironmentVariablesForPackage(const BuildConfiguration c
  */
 void setupEnvironmentVariablesForPackage(const BuildConfiguration cfg)
 {
-    import std.process;
     PackageDubVariables pack = getEnvironmentVariablesForPackage(cfg);
     static foreach(mem; __traits(allMembers, PackageDubVariables))
-        setEnvVariable(mem, __traits(getMember, pack, mem));
+        setEnvVariableNoLock(mem, __traits(getMember, pack, mem));
 }
 string parseStringWithEnvironment(string str)
 {
-    import std.process;
     import std.exception;
     import std.string;
     import std.ascii:isAlphaNum;
@@ -338,7 +336,29 @@ unittest
         parseStringWithEnvironment(`C:\Users\Marcelo\Documents\D\test\sokol-d\${SOKOL_D_PACKAGE_DIR}\src\sokol\c\sokol_log.c`) ==
         `C:\Users\Marcelo\Documents\D\test\sokol-d\test\src\sokol\c\sokol_log.c`
     );
+}
 
+/**
+*   cfg = Config to parse environment inside the preGenerateCommands
+*   outEnv = Output environment to be used for the preGenerateCommands
+*/
+BuildConfiguration parseEnvironmentForPreGenerate(BuildConfiguration cfg, out string[string] outEnv)
+{
+    //In this part it does need to lock since it runs on parallel.
+    PackageDubVariables pack = getEnvironmentVariablesForPackage(cfg);
+    lockEnv();
+    scope(exit)
+        unlockEnv();
+    static foreach(mem; __traits(allMembers, PackageDubVariables))
+        setEnvVariableNoLock(mem, __traits(getMember, pack, mem));
+    outEnv = getRedubEnv();
+    redub.parsers.environment.setupEnvironmentVariablesForPackage(cfg);
+    with(cfg)
+    {
+        if(cfg.commands.length > RedubCommands.preGenerate)
+            cfg.commands[RedubCommands.preGenerate] = arrParseEnv(cfg.commands[RedubCommands.preGenerate]);
+    }
+    return cfg;
 }
 
 /** 
@@ -360,8 +380,6 @@ BuildConfiguration parseEnvironment(BuildConfiguration cfg)
         dFlags = arrParseEnv(dFlags);
         linkFlags = arrParseEnv(linkFlags);
 
-        if(cfg.commands.length > RedubCommands.preGenerate)
-            cfg.commands[RedubCommands.preGenerate] = arrParseEnv(cfg.commands[RedubCommands.preGenerate]);
         if(cfg.commands.length > RedubCommands.postGenerate)
             cfg.commands[RedubCommands.postGenerate] = arrParseEnv(cfg.commands[RedubCommands.postGenerate]);
         if(cfg.commands.length > RedubCommands.preBuild)
@@ -447,7 +465,9 @@ version(AsLibrary) //Library version will use environment instead of redubEnv si
      *   key =
      *   value =
      */
+    
     void setEnvVariable(string key, string value){environment[key] = value;}
+    alias setEnvVariableNoLock = setEnvVariable;
     /**
      * Gets the environment as a string[string] to be used inside a function
      * Returns:
@@ -478,6 +498,8 @@ version(AsLibrary) //Library version will use environment instead of redubEnv si
         }
         return null;
     }
+    void lockEnv(){}
+    alias unlockEnv = lockEnv;
 }
 else
 {
@@ -491,7 +513,12 @@ else
             redubEnv[key] = value;
         }
     }
+
+    void setEnvVariableNoLock(string key, string value){redubEnv[key] = value;}
     string[string] getRedubEnv(){return redubEnv;}
+
+    void lockEnv(){envMutex.lock();}
+    void unlockEnv(){envMutex.unlock();}
     string getEnvVariable(string key)
     {
         string* ret = key in redubEnv;

source/redub/parsers/json.d

@@ -486,7 +486,7 @@ BuildRequirements parse(JSONValue json, ParseConfig cfg, out BuildConfiguration
     runHandlers(requirementsRun, buildRequirements, cfg, json, false, unusedKeys, pending);
 
     if(cfg.firstRun && unusedKeys.length) warn("Unused Keys -> ", unusedKeys);
-
+    runPreGenerateCommands(cfg, buildRequirements);
     return buildRequirements;
 }