Fork: 0
johnpearcey / dub_jkp
Transfer to URL with SHA Find file
Newer
Older
dub_jkp / source / dub / recipe / json.d
@Geod24 Geod24 on 25 Aug 2022 17 KB Integrate `dependencyBuildSettings` into dependencies
Raw Blame History 
  1. /**
  2. 	JSON format support for PackageRecipe
  3.  
  4. 	Copyright: © 2012-2014 rejectedsoftware e.K.
  5. 	License: Subject to the terms of the MIT license, as written in the included LICENSE.txt file.
  6. 	Authors: Sönke Ludwig, Matthias Dondorff
  7. */
  8. module dub.recipe.json;
  9.  
  10. import dub.compilers.compiler;
  11. import dub.dependency;
  12. import dub.recipe.packagerecipe;
  13.  
  14. import dub.internal.vibecompat.data.json;
  15.  
  16. import std.algorithm : canFind, startsWith;
  17. import std.conv : to;
  18. import std.exception : enforce;
  19. import std.range;
  20. import std.string : format, indexOf;
  21. import std.traits : EnumMembers;
  22.  
  23.  
  24. void parseJson(ref PackageRecipe recipe, Json json, string parent_name)
  25. {
  26. 	foreach (string field, value; json) {
  27. 		switch (field) {
  28. 			default: break;
  29. 			case "name": recipe.name = value.get!string; break;
  30. 			case "version": recipe.version_ = value.get!string; break;
  31. 			case "description": recipe.description = value.get!string; break;
  32. 			case "homepage": recipe.homepage = value.get!string; break;
  33. 			case "authors": recipe.authors = deserializeJson!(string[])(value); break;
  34. 			case "copyright": recipe.copyright = value.get!string; break;
  35. 			case "license": recipe.license = value.get!string; break;
  36. 			case "configurations": break; // handled below, after the global settings have been parsed
  37. 			case "buildTypes":
  38. 				foreach (string name, settings; value) {
  39. 					BuildSettingsTemplate bs;
  40. 					bs.parseJson(settings, null);
  41. 					recipe.buildTypes[name] = bs;
  42. 				}
  43. 				break;
  44. 			case "toolchainRequirements":
  45. 				recipe.toolchainRequirements.parseJson(value);
  46. 				break;
  47. 			case "-ddoxFilterArgs": recipe.ddoxFilterArgs = deserializeJson!(string[])(value); break;
  48. 			case "-ddoxTool": recipe.ddoxTool = value.get!string; break;
  49. 		}
  50. 	}
  51.  
  52. 	enforce(recipe.name.length > 0, "The package \"name\" field is missing or empty.");
  53.  
  54. 	auto fullname = parent_name.length ? parent_name ~ ":" ~ recipe.name : recipe.name;
  55.  
  56. 	// parse build settings
  57. 	recipe.buildSettings.parseJson(json, fullname);
  58.  
  59. 	if (auto pv = "configurations" in json) {
  60. 		foreach (settings; *pv) {
  61. 			ConfigurationInfo ci;
  62. 			ci.parseJson(settings, recipe.name);
  63. 			recipe.configurations ~= ci;
  64. 		}
  65. 	}
  66.  
  67. 	// parse any sub packages after the main package has been fully parsed
  68. 	if (auto ps = "subPackages" in json)
  69. 		recipe.parseSubPackages(fullname, ps.opt!(Json[]));
  70. }
  71.  
  72. Json toJson(const scope ref PackageRecipe recipe)
  73. {
  74. 	auto ret = recipe.buildSettings.toJson();
  75. 	ret["name"] = recipe.name;
  76. 	if (!recipe.version_.empty) ret["version"] = recipe.version_;
  77. 	if (!recipe.description.empty) ret["description"] = recipe.description;
  78. 	if (!recipe.homepage.empty) ret["homepage"] = recipe.homepage;
  79. 	if (!recipe.authors.empty) ret["authors"] = serializeToJson(recipe.authors);
  80. 	if (!recipe.copyright.empty) ret["copyright"] = recipe.copyright;
  81. 	if (!recipe.license.empty) ret["license"] = recipe.license;
  82. 	if (!recipe.subPackages.empty) {
  83. 		Json[] jsonSubPackages = new Json[recipe.subPackages.length];
  84. 		foreach (i, subPackage; recipe.subPackages) {
  85. 			if (subPackage.path !is null) {
  86. 				jsonSubPackages[i] = Json(subPackage.path);
  87. 			} else {
  88. 				jsonSubPackages[i] = subPackage.recipe.toJson();
  89. 			}
  90. 		}
  91. 		ret["subPackages"] = jsonSubPackages;
  92. 	}
  93. 	if (recipe.configurations.length) {
  94. 		Json[] configs;
  95. 		foreach(config; recipe.configurations)
  96. 			configs ~= config.toJson();
  97. 		ret["configurations"] = configs;
  98. 	}
  99. 	if (recipe.buildTypes.length) {
  100. 		Json[string] types;
  101. 		foreach (name, settings; recipe.buildTypes)
  102. 			types[name] = settings.toJson();
  103. 		ret["buildTypes"] = types;
  104. 	}
  105. 	if (!recipe.toolchainRequirements.empty) {
  106. 		ret["toolchainRequirements"] = recipe.toolchainRequirements.toJson();
  107. 	}
  108. 	if (!recipe.ddoxFilterArgs.empty) ret["-ddoxFilterArgs"] = recipe.ddoxFilterArgs.serializeToJson();
  109. 	if (!recipe.ddoxTool.empty) ret["-ddoxTool"] = recipe.ddoxTool;
  110. 	return ret;
  111. }
  112.  
  113. private void parseSubPackages(ref PackageRecipe recipe, string parent_package_name, Json[] subPackagesJson)
  114. {
  115. 	enforce(!parent_package_name.canFind(":"), format("'subPackages' found in '%s'. This is only supported in the main package file for '%s'.",
  116. 		parent_package_name, getBasePackageName(parent_package_name)));
  117.  
  118. 	recipe.subPackages = new SubPackage[subPackagesJson.length];
  119. 	foreach (i, subPackageJson; subPackagesJson) {
  120. 		// Handle referenced Packages
  121. 		if(subPackageJson.type == Json.Type.string) {
  122. 			string subpath = subPackageJson.get!string;
  123. 			recipe.subPackages[i] = SubPackage(subpath, PackageRecipe.init);
  124. 		} else {
  125. 			PackageRecipe subinfo;
  126. 			subinfo.parseJson(subPackageJson, parent_package_name);
  127. 			recipe.subPackages[i] = SubPackage(null, subinfo);
  128. 		}
  129. 	}
  130. }
  131.  
  132. private void parseJson(ref ConfigurationInfo config, Json json, string package_name)
  133. {
  134. 	foreach (string name, value; json) {
  135. 		switch (name) {
  136. 			default: break;
  137. 			case "name":
  138. 				config.name = value.get!string;
  139. 				enforce(!config.name.empty, "Configurations must have a non-empty name.");
  140. 				break;
  141. 			case "platforms": config.platforms = deserializeJson!(string[])(value); break;
  142. 		}
  143. 	}
  144.  
  145. 	enforce(!config.name.empty, "Configuration is missing a name.");
  146. 	config.buildSettings.parseJson(json, package_name);
  147. }
  148.  
  149. private Json toJson(const scope ref ConfigurationInfo config)
  150. {
  151. 	auto ret = config.buildSettings.toJson();
  152. 	ret["name"] = config.name;
  153. 	if (config.platforms.length) ret["platforms"] = serializeToJson(config.platforms);
  154. 	return ret;
  155. }
  156.  
  157. private void parseJson(ref BuildSettingsTemplate bs, Json json, string package_name)
  158. {
  159. 	foreach(string name, value; json)
  160. 	{
  161. 		auto idx = indexOf(name, "-");
  162. 		string basename, suffix;
  163. 		if( idx >= 0 ) { basename = name[0 .. idx]; suffix = name[idx + 1 .. $]; }
  164. 		else basename = name;
  165. 		switch(basename){
  166. 			default: break;
  167. 			case "dependencies":
  168. 				foreach (string pkg, verspec; value) {
  169. 					if (pkg.startsWith(":")) {
  170. 						enforce(!package_name.canFind(':'), format("Short-hand packages syntax not allowed within sub packages: %s -> %s", package_name, pkg));
  171. 						pkg = package_name ~ pkg;
  172. 					}
  173. 					enforce(pkg !in bs.dependencies, "The dependency '"~pkg~"' is specified more than once." );
  174. 					bs.dependencies[pkg] = Dependency.fromJson(verspec);
  175. 					if (verspec.type == Json.Type.object)
  176. 						bs.dependencies[pkg].settings.parseJson(verspec, package_name);
  177. 				}
  178. 				break;
  179. 			case "systemDependencies":
  180. 				bs.systemDependencies = value.get!string;
  181. 				break;
  182. 			case "targetType":
  183. 				enforce(suffix.empty, "targetType does not support platform customization.");
  184. 				bs.targetType = value.get!string.to!TargetType;
  185. 				break;
  186. 			case "targetPath":
  187. 				enforce(suffix.empty, "targetPath does not support platform customization.");
  188. 				bs.targetPath = value.get!string;
  189. 				break;
  190. 			case "targetName":
  191. 				enforce(suffix.empty, "targetName does not support platform customization.");
  192. 				bs.targetName = value.get!string;
  193. 				break;
  194. 			case "workingDirectory":
  195. 				enforce(suffix.empty, "workingDirectory does not support platform customization.");
  196. 				bs.workingDirectory = value.get!string;
  197. 				break;
  198. 			case "mainSourceFile":
  199. 				enforce(suffix.empty, "mainSourceFile does not support platform customization.");
  200. 				bs.mainSourceFile = value.get!string;
  201. 				break;
  202. 			case "subConfigurations":
  203. 				enforce(suffix.empty, "subConfigurations does not support platform customization.");
  204. 				bs.subConfigurations = deserializeJson!(string[string])(value);
  205. 				break;
  206. 			case "dflags": bs.dflags[suffix] = deserializeJson!(string[])(value); break;
  207. 			case "lflags": bs.lflags[suffix] = deserializeJson!(string[])(value); break;
  208. 			case "libs": bs.libs[suffix] = deserializeJson!(string[])(value); break;
  209. 			case "files":
  210. 			case "sourceFiles": bs.sourceFiles[suffix] = deserializeJson!(string[])(value); break;
  211. 			case "sourcePaths": bs.sourcePaths[suffix] = deserializeJson!(string[])(value); break;
  212. 			case "sourcePath": bs.sourcePaths[suffix] ~= [value.get!string]; break; // deprecated
  213. 			case "excludedSourceFiles": bs.excludedSourceFiles[suffix] = deserializeJson!(string[])(value); break;
  214. 			case "injectSourceFiles": bs.injectSourceFiles[suffix] = deserializeJson!(string[])(value); break;
  215. 			case "copyFiles": bs.copyFiles[suffix] = deserializeJson!(string[])(value); break;
  216. 			case "extraDependencyFiles": bs.extraDependencyFiles[suffix] = deserializeJson!(string[])(value); break;
  217. 			case "versions": bs.versions[suffix] = deserializeJson!(string[])(value); break;
  218. 			case "debugVersions": bs.debugVersions[suffix] = deserializeJson!(string[])(value); break;
  219. 			case "-versionFilters": bs.versionFilters[suffix] = deserializeJson!(string[])(value); break;
  220. 			case "-debugVersionFilters": bs.debugVersionFilters[suffix] = deserializeJson!(string[])(value); break;
  221. 			case "importPaths": bs.importPaths[suffix] = deserializeJson!(string[])(value); break;
  222. 			case "stringImportPaths": bs.stringImportPaths[suffix] = deserializeJson!(string[])(value); break;
  223. 			case "preGenerateCommands": bs.preGenerateCommands[suffix] = deserializeJson!(string[])(value); break;
  224. 			case "postGenerateCommands": bs.postGenerateCommands[suffix] = deserializeJson!(string[])(value); break;
  225. 			case "preBuildCommands": bs.preBuildCommands[suffix] = deserializeJson!(string[])(value); break;
  226. 			case "postBuildCommands": bs.postBuildCommands[suffix] = deserializeJson!(string[])(value); break;
  227. 			case "preRunCommands": bs.preRunCommands[suffix] = deserializeJson!(string[])(value); break;
  228. 			case "postRunCommands": bs.postRunCommands[suffix] = deserializeJson!(string[])(value); break;
  229. 			case "environments": bs.environments[suffix] = deserializeJson!(string[string])(value); break;
  230. 			case "buildEnvironments": bs.buildEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  231. 			case "runEnvironments": bs.runEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  232. 			case "preGenerateEnvironments": bs.preGenerateEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  233. 			case "postGenerateEnvironments": bs.postGenerateEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  234. 			case "preBuildEnvironments": bs.preBuildEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  235. 			case "postBuildEnvironments": bs.postBuildEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  236. 			case "preRunEnvironments": bs.preRunEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  237. 			case "postRunEnvironments": bs.postRunEnvironments[suffix] = deserializeJson!(string[string])(value); break;
  238. 			case "buildRequirements":
  239. 				Flags!BuildRequirement reqs;
  240. 				foreach (req; deserializeJson!(string[])(value))
  241. 					reqs |= to!BuildRequirement(req);
  242. 				bs.buildRequirements[suffix] = reqs;
  243. 				break;
  244. 			case "buildOptions":
  245. 				Flags!BuildOption options;
  246. 				foreach (opt; deserializeJson!(string[])(value))
  247. 					options |= to!BuildOption(opt);
  248. 				bs.buildOptions[suffix] = options;
  249. 				break;
  250. 		}
  251. 	}
  252. }
  253.  
  254. private Json toJson(const scope ref BuildSettingsTemplate bs)
  255. {
  256. 	static string withSuffix (string pre, string post)
  257. 	{
  258. 		if (!post.length)
  259. 			return pre;
  260. 		return pre ~ "-" ~ post;
  261. 	}
  262.  
  263. 	auto ret = Json.emptyObject;
  264. 	if( bs.dependencies !is null ){
  265. 		auto deps = Json.emptyObject;
  266. 		foreach( pack, d; bs.dependencies )
  267. 			deps[pack] = d.toJson();
  268. 		ret["dependencies"] = deps;
  269. 	}
  270. 	if (bs.systemDependencies !is null) ret["systemDependencies"] = bs.systemDependencies;
  271. 	if (bs.targetType != TargetType.autodetect) ret["targetType"] = bs.targetType.to!string();
  272. 	if (!bs.targetPath.empty) ret["targetPath"] = bs.targetPath;
  273. 	if (!bs.targetName.empty) ret["targetName"] = bs.targetName;
  274. 	if (!bs.workingDirectory.empty) ret["workingDirectory"] = bs.workingDirectory;
  275. 	if (!bs.mainSourceFile.empty) ret["mainSourceFile"] = bs.mainSourceFile;
  276. 	if (bs.subConfigurations.length > 0) ret["subConfigurations"] = serializeToJson(bs.subConfigurations);
  277. 	foreach (suffix, arr; bs.dflags) ret[withSuffix("dflags", suffix)] = serializeToJson(arr);
  278. 	foreach (suffix, arr; bs.lflags) ret[withSuffix("lflags", suffix)] = serializeToJson(arr);
  279. 	foreach (suffix, arr; bs.libs) ret[withSuffix("libs", suffix)] = serializeToJson(arr);
  280. 	foreach (suffix, arr; bs.sourceFiles) ret[withSuffix("sourceFiles", suffix)] = serializeToJson(arr);
  281. 	foreach (suffix, arr; bs.sourcePaths) ret[withSuffix("sourcePaths", suffix)] = serializeToJson(arr);
  282. 	foreach (suffix, arr; bs.excludedSourceFiles) ret[withSuffix("excludedSourceFiles", suffix)] = serializeToJson(arr);
  283. 	foreach (suffix, arr; bs.injectSourceFiles) ret[withSuffix("injectSourceFiles", suffix)] = serializeToJson(arr);
  284. 	foreach (suffix, arr; bs.copyFiles) ret[withSuffix("copyFiles", suffix)] = serializeToJson(arr);
  285. 	foreach (suffix, arr; bs.extraDependencyFiles) ret[withSuffix("extraDependencyFiles", suffix)] = serializeToJson(arr);
  286. 	foreach (suffix, arr; bs.versions) ret[withSuffix("versions", suffix)] = serializeToJson(arr);
  287. 	foreach (suffix, arr; bs.debugVersions) ret[withSuffix("debugVersions", suffix)] = serializeToJson(arr);
  288. 	foreach (suffix, arr; bs.versionFilters) ret[withSuffix("-versionFilters", suffix)] = serializeToJson(arr);
  289. 	foreach (suffix, arr; bs.debugVersionFilters) ret[withSuffix("-debugVersionFilters", suffix)] = serializeToJson(arr);
  290. 	foreach (suffix, arr; bs.importPaths) ret[withSuffix("importPaths", suffix)] = serializeToJson(arr);
  291. 	foreach (suffix, arr; bs.stringImportPaths) ret[withSuffix("stringImportPaths", suffix)] = serializeToJson(arr);
  292. 	foreach (suffix, arr; bs.preGenerateCommands) ret[withSuffix("preGenerateCommands", suffix)] = serializeToJson(arr);
  293. 	foreach (suffix, arr; bs.postGenerateCommands) ret[withSuffix("postGenerateCommands", suffix)] = serializeToJson(arr);
  294. 	foreach (suffix, arr; bs.preBuildCommands) ret[withSuffix("preBuildCommands", suffix)] = serializeToJson(arr);
  295. 	foreach (suffix, arr; bs.postBuildCommands) ret[withSuffix("postBuildCommands", suffix)] = serializeToJson(arr);
  296. 	foreach (suffix, arr; bs.preRunCommands) ret[withSuffix("preRunCommands", suffix)] = serializeToJson(arr);
  297. 	foreach (suffix, arr; bs.postRunCommands) ret[withSuffix("postRunCommands", suffix)] = serializeToJson(arr);
  298. 	foreach (suffix, aa; bs.environments) ret[withSuffix("environments", suffix)] = serializeToJson(aa);
  299. 	foreach (suffix, aa; bs.buildEnvironments) ret[withSuffix("buildEnvironments", suffix)] = serializeToJson(aa);
  300. 	foreach (suffix, aa; bs.runEnvironments) ret[withSuffix("runEnvironments", suffix)] = serializeToJson(aa);
  301. 	foreach (suffix, aa; bs.preGenerateEnvironments) ret[withSuffix("preGenerateEnvironments", suffix)] = serializeToJson(aa);
  302. 	foreach (suffix, aa; bs.postGenerateEnvironments) ret[withSuffix("postGenerateEnvironments", suffix)] = serializeToJson(aa);
  303. 	foreach (suffix, aa; bs.preBuildEnvironments) ret[withSuffix("preBuildEnvironments", suffix)] = serializeToJson(aa);
  304. 	foreach (suffix, aa; bs.postBuildEnvironments) ret[withSuffix("postBuildEnvironments", suffix)] = serializeToJson(aa);
  305. 	foreach (suffix, aa; bs.preRunEnvironments) ret[withSuffix("preRunEnvironments", suffix)] = serializeToJson(aa);
  306. 	foreach (suffix, aa; bs.postRunEnvironments) ret[withSuffix("postRunEnvironments", suffix)] = serializeToJson(aa);
  307. 	foreach (suffix, arr; bs.buildRequirements) {
  308. 		string[] val;
  309. 		foreach (i; [EnumMembers!BuildRequirement])
  310. 			if (arr & i) val ~= to!string(i);
  311. 		ret[withSuffix("buildRequirements", suffix)] = serializeToJson(val);
  312. 	}
  313. 	foreach (suffix, arr; bs.buildOptions) {
  314. 		string[] val;
  315. 		foreach (i; [EnumMembers!BuildOption])
  316. 			if (arr & i) val ~= to!string(i);
  317. 		ret[withSuffix("buildOptions", suffix)] = serializeToJson(val);
  318. 	}
  319. 	return ret;
  320. }
  321.  
  322. private void parseJson(ref ToolchainRequirements tr, Json json)
  323. {
  324. 	foreach (string name, value; json)
  325. 		tr.addRequirement(name, value.get!string);
  326. }
  327.  
  328. private Json toJson(const scope ref ToolchainRequirements tr)
  329. {
  330. 	auto ret = Json.emptyObject;
  331. 	if (tr.dub != Dependency.any) ret["dub"] = serializeToJson(tr.dub);
  332. 	if (tr.frontend != Dependency.any) ret["frontend"] = serializeToJson(tr.frontend);
  333. 	if (tr.dmd != Dependency.any) ret["dmd"] = serializeToJson(tr.dmd);
  334. 	if (tr.ldc != Dependency.any) ret["ldc"] = serializeToJson(tr.ldc);
  335. 	if (tr.gdc != Dependency.any) ret["gdc"] = serializeToJson(tr.gdc);
  336. 	return ret;
  337. }
  338.  
  339. unittest {
  340. 	import std.string: strip, outdent;
  341. 	static immutable json = `
  342. 		{
  343. 			"name": "projectname",
  344. 			"environments": {
  345. 				"Var1": "env"
  346. 			},
  347. 			"buildEnvironments": {
  348. 				"Var2": "buildEnv"
  349. 			},
  350. 			"runEnvironments": {
  351. 				"Var3": "runEnv"
  352. 			},
  353. 			"preGenerateEnvironments": {
  354. 				"Var4": "preGenEnv"
  355. 			},
  356. 			"postGenerateEnvironments": {
  357. 				"Var5": "postGenEnv"
  358. 			},
  359. 			"preBuildEnvironments": {
  360. 				"Var6": "preBuildEnv"
  361. 			},
  362. 			"postBuildEnvironments": {
  363. 				"Var7": "postBuildEnv"
  364. 			},
  365. 			"preRunEnvironments": {
  366. 				"Var8": "preRunEnv"
  367. 			},
  368. 			"postRunEnvironments": {
  369. 				"Var9": "postRunEnv"
  370. 			}
  371. 		}
  372. 	`.strip.outdent;
  373. 	auto jsonValue = parseJsonString(json);
  374. 	PackageRecipe rec1;
  375. 	parseJson(rec1, jsonValue, null);
  376. 	PackageRecipe rec;
  377. 	parseJson(rec, rec1.toJson(), null); // verify that all fields are serialized properly
  378.  
  379. 	assert(rec.name == "projectname");
  380. 	assert(rec.buildSettings.environments == ["": ["Var1": "env"]]);
  381. 	assert(rec.buildSettings.buildEnvironments == ["": ["Var2": "buildEnv"]]);
  382. 	assert(rec.buildSettings.runEnvironments == ["": ["Var3": "runEnv"]]);
  383. 	assert(rec.buildSettings.preGenerateEnvironments == ["": ["Var4": "preGenEnv"]]);
  384. 	assert(rec.buildSettings.postGenerateEnvironments == ["": ["Var5": "postGenEnv"]]);
  385. 	assert(rec.buildSettings.preBuildEnvironments == ["": ["Var6": "preBuildEnv"]]);
  386. 	assert(rec.buildSettings.postBuildEnvironments == ["": ["Var7": "postBuildEnv"]]);
  387. 	assert(rec.buildSettings.preRunEnvironments == ["": ["Var8": "preRunEnv"]]);
  388. 	assert(rec.buildSettings.postRunEnvironments == ["": ["Var9": "postRunEnv"]]);
  389. }