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 }