Update: Preparing redub to receive target configuration

Author: MrcSnm

source/redub/api.d

@@ -792,7 +792,7 @@ ProjectDetails resolveDependencies(
         DUB_FORCE = either(DUB_FORCE, redub.parsers.environment.str(resolveInfo.force));
     }
     redub.parsers.environment.setupBuildEnvironmentVariables(dubVars);
-    CompilationInfo cInfo = CompilationInfo(compiler.d.getCompilerString, compiler.c.getCompilerString, cDetails.arch, osFromArch(cDetails.arch), isaFromArch(cDetails.arch), compiler.d.bin);
+    CompilationInfo cInfo = CompilationInfo(compiler, cDetails.arch);
     if(proj.workingDir == null)
     {
         import std.file;
@@ -807,8 +807,6 @@ ProjectDetails resolveDependencies(
             BuildRequirements.Configuration(proj.configuration, false),
             proj.subPackage,
             proj.recipe,
-            true,
-            null,
             cDetails.useExistingObj
         );
     else
@@ -818,9 +816,6 @@ ProjectDetails resolveDependencies(
             BuildRequirements.Configuration(proj.configuration, false),
             proj.subPackage,
             proj.recipe,
-            null,
-            true,
-            null,
             cDetails.useExistingObj,
             proj.isDescribeOnly
         );

source/redub/parsers/adapter/json_cache.d

@@ -0,0 +1,43 @@
+module redub.parsers.adapter.json_cache;
+public import hip.data.json;
+
+private __gshared JSONValue[string] jsonCache;
+
+/**
+ * Params:
+ *   filePath = Uses filePath as the file data for parsing. Better API
+ * Returns: Same as parseJSONCache
+ */
+JSONValue parseJSONCached(string filePath)
+{
+    import std.file;
+    return parseJSONCached(filePath, std.file.readText(filePath));
+}
+
+/**
+ * Optimization to be used when dealing with subPackages.
+ * Params:
+ *   filePath = The path to use for getting it from cache, used simply as a key to the jsonCache
+ *   fileData = The actual content to be used for parsing
+ */
+JSONValue parseJSONCached(string filePath, string fileData)
+{
+    synchronized
+    {
+        JSONValue* cached = filePath in jsonCache;
+        if(cached) return *cached;
+        jsonCache[filePath] = parseJSON(fileData, true);
+        if(jsonCache[filePath].hasErrorOccurred)
+            throw new Exception(jsonCache[filePath].error);
+        return jsonCache[filePath];
+    }
+}
+
+/**
+ * This function was created since on libraries, they may be reusing multiple times and thus
+ * storing the cache between runs may trigger errors.
+ */
+public void clearJsonCache()
+{
+    jsonCache = null;
+}

source/redub/parsers/adapter/sdl.d

@@ -0,0 +1,23 @@
+module redub.parsers.adapter.sdl;
+public import redub.buildapi;
+import hip.data.json;
+
+JSONValue sdlToJSONCache(string filePath)
+{
+    import std.file;
+    return sdlToJSONCache(filePath, readText(filePath));
+}
+
+private JSONValue[string] sdlJsonCache;
+JSONValue sdlToJSONCache(string filePath, string fileData)
+{
+    import dub_sdl_to_json;
+    JSONValue* cached = filePath in sdlJsonCache;
+    if(cached) return *cached;
+    JSONValue ret = sdlToJSON(parseSDL(filePath, fileData));
+    if(ret.hasErrorOccurred)
+        throw new Exception(ret.error);
+    return sdlJsonCache[filePath] = ret;
+}
+
+void clearSdlRecipeCache(){sdlJsonCache = null;}

source/redub/parsers/automatic.d

@@ -3,10 +3,98 @@ import redub.logging;
 public import redub.buildapi;
 public import std.system;
 static import redub.parsers.json;
-static import redub.parsers.sdl;
+static import redub.parsers.adapter.sdl;
 static import redub.parsers.environment;
 import redub.command_generators.commons;
 import redub.tree_generators.dub;
+import hip.data.json;
+
+/**
+ * Parses an initial directory, not recursively. Currently only .sdl and .json are parsed.
+ * After the parse happens, it also partially finishes the requirements by using a generalized fix
+ * for after the parsing stage.
+ * Params:
+ *   projectWorkingDir = Optional working dir. What is the root being considered for the recipe file
+ *   cInfo = Important compilation info for that project
+ *   subConfiguration = Sub configuration to use
+ *   subPackage = Optional sub package
+ *   recipe = Optional recipe to read. Its path is not used as root.
+ *   version = The actual version of that project, may be null on root
+ *   useExistingObj = Makes the project output dependencies if it is a root project. Disabled by default since compilation may be way slower
+ *   isDescribeOnly = Do not execute preGenerate commands when true
+ * Returns: The build requirements to the project. Not recursive.
+ */
+BuildRequirements parseProject(
+    string projectWorkingDir,
+    ref CompilationInfo cInfo,
+    BuildRequirements.Configuration subConfiguration,
+    string subPackage,
+    string recipe,
+    bool useExistingObj = false,
+    bool isDescribeOnly = false
+)
+{
+    import redub.parsers.base;
+    import std.path;
+    import std.file;
+    import redub.package_searching.entry;
+    string projectFile = findEntryProjectFile(projectWorkingDir, recipe);
+    if(!projectFile)
+        throw new Exception("Directory '"~projectWorkingDir~"' has no recipe or does not exists.");
+
+    if(getLogLevel() >= LogLevel.verbose)
+    {
+        import std.string;
+        if(projectFile.startsWith(projectWorkingDir))
+            vlog("Parsing ", projectFile);
+        else
+            vlog("Parsing ", projectFile, " at ", projectWorkingDir);
+        if(subPackage)
+            vlog("\tSubPackage: ", subPackage);
+        if(subConfiguration.name)
+            vlog("\tConfiguration: ", subConfiguration.name);
+    }
+
+    JSONValue projectJSON = getProjectJSON(projectFile, projectWorkingDir);
+    return parseProject(projectJSON, projectWorkingDir, cInfo, subConfiguration, subPackage, useExistingObj, isDescribeOnly);
+}
+
+/**
+ * Parses an initial directory, not recursively. Currently only .sdl and .json are parsed.
+ * After the parse happens, it also partially finishes the requirements by using a generalized fix
+ * for after the parsing stage.
+ * Params:
+ *   projectWorkingDir = Optional working dir. What is the root being considered for the recipe file
+ *   cInfo = Important compilation info for that project
+ *   subConfiguration = Sub configuration to use
+ *   subPackage = Optional sub package
+ *   version = The actual version of that project, may be null on root
+ *   useExistingObj = Makes the project output dependencies if it is a root project. Disabled by default since compilation may be way slower
+ *   isDescribeOnly = Do not execute preGenerate commands when true
+ * Returns: The build requirements to the project. Not recursive.
+ */
+BuildRequirements parseProject(
+    JSONValue projectJSON,
+    string projectWorkingDir,
+    ref CompilationInfo cInfo,
+    BuildRequirements.Configuration subConfiguration,
+    string subPackage,
+    bool useExistingObj = false,
+    bool isDescribeOnly = false
+)
+{
+    import redub.parsers.base;
+
+    ParseConfig cfg = getParseConfig(projectWorkingDir, cInfo, null, null, subConfiguration, subPackage, null, isDescribeOnly);
+        //Get target
+
+    // cfg = redub.parsers.json.getTarget(projectJSON, null, cfg);
+    BuildConfiguration pending;
+    BuildRequirements req = redub.parsers.json.parse(projectJSON, cfg, pending, true);
+    return postProcessBuildRequirements(req, pending, cInfo, true, useExistingObj);
+}
+
+
 
 /**
  * Parses an initial directory, not recursively. Currently only .sdl and .json are parsed.
@@ -25,9 +113,9 @@ import redub.tree_generators.dub;
  *   isDescribeOnly = Do not execute preGenerate commands when true
  * Returns: The build requirements to the project. Not recursive.
  */
-BuildRequirements parseProject(
+BuildRequirements parseProjectCommon(
     string projectWorkingDir,
-    CompilationInfo cInfo,
+    const ref CompilationInfo cInfo,
     BuildRequirements.Configuration subConfiguration,
     string subPackage,
     string recipe,
@@ -38,7 +126,7 @@ BuildRequirements parseProject(
     bool isDescribeOnly = false
 )
 {
-    import std.path;
+    import redub.parsers.base;
     import std.file;
     import redub.package_searching.entry;
     string projectFile = findEntryProjectFile(projectWorkingDir, recipe);
@@ -60,15 +148,29 @@ BuildRequirements parseProject(
     }
 
     BuildConfiguration pending;
+    ParseConfig cfg = getParseConfig(projectWorkingDir, cInfo, null, version_, subConfiguration, subPackage, parentName, isDescribeOnly);
+
+    JSONValue parseData = getProjectJSON(projectFile, projectWorkingDir);
+
+    req = redub.parsers.json.parse(parseData, cfg, pending, false);
+    return postProcessBuildRequirements(req, pending, cInfo, isRoot, useExistingObj);
+}
+
+JSONValue getProjectJSON(string projectFile, string projectWorkingDir)
+{
+    import std.path;
     switch(extension(projectFile))
     {
-        case ".sdl":   req = redub.parsers.sdl.parse(projectFile, projectWorkingDir, cInfo, null, version_, subConfiguration, subPackage, pending, parentName, isDescribeOnly, isRoot); break;
-        case ".json":  req = redub.parsers.json.parse(projectFile, projectWorkingDir, cInfo, null, version_, subConfiguration, subPackage, pending, parentName, isDescribeOnly, isRoot); break;
+        case ".sdl":
+            return redub.parsers.adapter.sdl.sdlToJSONCache(projectFile);
+        case ".json":
+            import redub.parsers.adapter.json_cache;
+            return parseJSONCached(projectFile);
         default: throw new Exception("Unsupported project type "~projectFile~" at dir "~projectWorkingDir);
     }
-    return postProcessBuildRequirements(req, pending, cInfo, isRoot, useExistingObj);
 }
 
+
 /**
  * Used mostly to check the name of a package in the local directory and decide what to build
  * Params:
@@ -83,10 +185,24 @@ string getPackageName(string projectWorkingDir, string recipe)
     string projectFile = findEntryProjectFile(projectWorkingDir, recipe);
     if(!projectFile)
         throw new Exception("Directory '"~projectWorkingDir~"' has no recipe or does not exists.");
+
+    JSONValue parseData;
+    bool hasInitData;
+
     switch(extension(projectFile))
     {
-        case ".sdl":   return redub.parsers.sdl.getPackageName(projectFile); break;
-        case ".json":  return redub.parsers.json.getPackageName(projectFile); break;
+        case ".sdl":
+            import redub.parsers.adapter.sdl;
+            parseData = sdlToJSONCache(projectFile);
+            hasInitData = true;
+            goto case ".json";
+        case ".json":  
+            if(!hasInitData)
+            {
+                import redub.parsers.adapter.json_cache;
+                parseData  = parseJSONCached(projectFile);
+            }
+            return redub.parsers.json.getPackageName(parseData);
         default: throw new Exception("Unsupported project type "~projectFile);
     }
 }
@@ -214,5 +330,5 @@ private void partiallyFinishBuildRequirements(ref BuildRequirements req, BuildCo
 void clearRecipeCaches()
 {
     redub.parsers.json.clearJsonRecipeCache();
-    redub.parsers.sdl.clearSdlRecipeCache();
+    redub.parsers.adapter.sdl.clearSdlRecipeCache();
 }

source/redub/parsers/base.d

@@ -28,6 +28,30 @@ struct ParseConfig
     bool isRoot = false;
 }
 
+/**
+*   projectWorkingDir = Working directory to parse with it
+*   cInfo = Compilation Info for being used as filters while parsing
+*   defaultPackageName = Package name to use if no name is found inside the recipe
+*   version_ = Version of the current one being parsed. May be used to decide which version to use
+*   subConfiguration = The configuration that was specified in the parsing process
+*   subPackage = The subpackage that is actually being used
+*   parentName = Used as metadata
+*   isDescribeOnly = Whether or not to do a preGenerateRun
+*/
+ParseConfig getParseConfig(
+    string projectWorkingDir,
+    CompilationInfo cInfo,
+    string defaultPackageName,
+    string version_,
+    BuildRequirements.Configuration subConfiguration,
+    string subPackage,
+    string parentName,
+    bool isDescribeOnly = false)
+{
+    return ParseConfig(projectWorkingDir, subConfiguration, subPackage, version_, cInfo, defaultPackageName, ParseSubConfig(null, parentName), preGenerateRun: !isDescribeOnly);
+}
+
+
 ///Supplemental information for ParseConfig
 struct ParseSubConfig
 {