bool TryInterpretDubListOutput(DubProject prj, string outp)
{
if (string.IsNullOrEmpty(outp))
{
return(false);
}
bool ret = false;
foreach (Match match in dubInstalledPackagesOutputRegex.Matches(outp))
{
ret = true;
if (match.Success)
{
foreach (var kv in prj.DubReferences.GetDependencyEntries())
{
var dep = kv.Value;
if (kv.Key == match.Groups["name"].Value && string.IsNullOrWhiteSpace(dep.Path) &&
(string.IsNullOrEmpty(dep.Version) || CheckRequiredDepVersion(dep.Version, match.Groups["version"].Value)))
{
dep.Path = match.Groups["path"].Value.Trim();
}
}
}
}
return(ret);
}
void FillDubReferencesPaths(DubProject prj)
{
string err, outp;
var baseDir = prj.BaseDirectory.ToString();
if (DubListOutputs.TryGetValue(baseDir, out outp))
{
TryInterpretDubListOutput(prj, outp);
}
else
{
try
{
ProjectBuilder.ExecuteCommand(DubSettings.Instance.DubCommand, "list", baseDir, null, out err, out outp);
// Backward compatiblity
if (!string.IsNullOrWhiteSpace(err) || !TryInterpretDubListOutput(prj, outp))
{
ProjectBuilder.ExecuteCommand(DubSettings.Instance.DubCommand, "list-installed", baseDir, null, out err, out outp);
TryInterpretDubListOutput(prj, outp);
}
if (!string.IsNullOrWhiteSpace(outp))
{
DubListOutputs[baseDir] = outp;
}
}
catch (Exception ex)
{
LoggingService.LogError("Error while resolving dub dependencies via executing 'dub list-installed'", ex);
}
}
prj.DubReferences.FireUpdate();
}
protected override DubProject ReadSubPackage(DubProject superProject, object definition)
{
if (definition is SDLObject)
return Load (superProject, superProject.ParentSolution, definition, superProject.FileName);
throw new ArgumentException ("definition");
}
void TryPopulateProperty(DubProject prj, string propName, JSONThing j, List <Object> subPackages)
{
switch (propName)
{
case "displayname":
prj.Name = ExpectJsonStringValue(j, propName);
break;
case "name":
prj.packageName = ExpectJsonStringValue(j, propName);
break;
case "description":
prj.Description = ExpectJsonStringValue(j, propName);
break;
case "copyright":
prj.Copyright = ExpectJsonStringValue(j, propName);
break;
case "homepage":
prj.Homepage = ExpectJsonStringValue(j, propName);
break;
case "authors":
prj.Authors.Clear();
foreach (var authorValue in ExpectJsonArray(j, propName).Items)
{
prj.Authors.Add(ExpectJsonStringValue(authorValue, propName));
}
break;
case "dependencies":
DeserializeDubPrjDependencies(ExpectJsonObject(j, propName), prj.CommonBuildSettings);
break;
case "configurations":
foreach (var o in ExpectJsonArray(j, propName).Items)
{
IntroduceConfiguration(prj, DeserializeFromPackageJson(ExpectJsonObject(o, propName)));
}
break;
case "subpackages":
subPackages.AddRange(ExpectJsonArray(j, propName).Items);
break;
case "buildtypes":
foreach (var kv in ExpectJsonObject(j, propName).Properties)
{
prj.buildTypes.Add(kv.Key);
}
break;
default:
TryDeserializeBuildSetting(prj.CommonBuildSettings, propName, j);
break;
}
}
protected override DubProject ReadSubPackage(DubProject superProject, Object definition)
{
if(definition is JSONValueLeaf)
return DubFileManager.Instance.LoadProject(GetDubFilePath(superProject, (definition as JSONValueLeaf).Value), superProject.ParentSolution, null, DubFileManager.LoadFlags.None, superProject);
if (definition is JSONObject)
return Load (superProject, superProject.ParentSolution, definition as JSONObject, superProject.FileName);
throw new InvalidDataException ("definition");
}
public DubProject Load(DubProject superPackage, Solution parentSolution, Object streamReader, string originalFile)
{
bool returnSubProject = superPackage != null;
var defaultPackage = returnSubProject ? new DubSubPackage() : new DubProject();
defaultPackage.FileName = originalFile;
defaultPackage.BaseDirectory = defaultPackage.FileName.ParentDirectory;
if (returnSubProject)
{
var sub = defaultPackage as DubSubPackage;
sub.OriginalBasePath = superPackage is DubSubPackage ? (superPackage as DubSubPackage).OriginalBasePath :
superPackage.BaseDirectory;
sub.VirtualBasePath = sub.OriginalBasePath;
}
defaultPackage.BeginLoad();
defaultPackage.AddProjectAndSolutionConfiguration(new DubProjectConfiguration { Name = GettextCatalog.GetString("Default"), Id = DubProjectConfiguration.DefaultConfigId });
if (returnSubProject)
{
superPackage.packagesToAdd.Add(defaultPackage);
}
Read(defaultPackage, streamReader);
// Fill dub references
if (defaultPackage.DubReferences.Any(dep => string.IsNullOrWhiteSpace(dep.Path)))
FillDubReferencesPaths(defaultPackage);
else
defaultPackage.DubReferences.FireUpdate();
if (returnSubProject)
{
defaultPackage.packageName = superPackage.packageName + ":" + (defaultPackage.packageName ?? string.Empty);
var sub = defaultPackage as DubSubPackage;
var sourcePaths = sub.GetSourcePaths().ToArray();
if (sourcePaths.Length > 0 && !string.IsNullOrWhiteSpace(sourcePaths[0]))
sub.VirtualBasePath = new FilePath(sourcePaths[0]);
// TODO: What to do with new configurations that were declared in this sub package? Add them to all other packages as well?
}
defaultPackage.Items.Add(new ProjectFile(originalFile, BuildAction.None));
// https://github.com/aBothe/Mono-D/issues/555
var dubSelectionJsonPath = defaultPackage.BaseDirectory.Combine(DubSelectionsJsonFile);
if (File.Exists(dubSelectionJsonPath))
defaultPackage.Items.Add(new ProjectFile(dubSelectionJsonPath, BuildAction.None));
defaultPackage.EndLoad();
return defaultPackage;
}
protected override DubProject ReadSubPackage(DubProject superProject, object definition)
{
if (definition is SDLObject)
{
return(Load(superProject, superProject.ParentSolution, definition, superProject.FileName));
}
throw new ArgumentException("definition");
}
protected override void Read(DubProject target, Object input, List<Object> subPackages)
{
var json = input as JSONObject;
if (input is TextReader)
json = new JSONThingDeserializer().Deserialize (input as TextReader);
else if(json == null)
throw new ArgumentException("input");
foreach (var kv in json.Properties)
TryPopulateProperty (target, kv.Key, kv.Value, subPackages);
}
void Parse(JsonReader r, DubProject prj)
{
while (r.Read())
{
if (r.TokenType == JsonToken.PropertyName)
{
var propName = r.Value as string;
TryPopulateProperty(prj, propName, r);
}
else if (r.TokenType == JsonToken.EndObject)
break;
}
}
protected override DubProject ReadSubPackage(DubProject superProject, Object definition)
{
if (definition is JSONValueLeaf)
{
return(DubFileManager.Instance.LoadProject(GetDubFilePath(superProject, (definition as JSONValueLeaf).Value), superProject.ParentSolution, null, DubFileManager.LoadFlags.None, superProject));
}
if (definition is JSONObject)
{
return(Load(superProject, superProject.ParentSolution, definition as JSONObject, superProject.FileName));
}
throw new InvalidDataException("definition");
}
protected override void Read(DubProject target, Object input)
{
if (input is JsonReader)
Parse(input as JsonReader, target);
else if (input is TextReader)
{
using (var r = new JsonTextReader(input as TextReader))
{
Parse(r, target);
}
}
else
throw new ArgumentException("input");
}
protected override void Read(DubProject target, Object input, List<Object> subPackagesToBeReadLater)
{
if (input is StreamReader)
{
var tree = SDL.SdlParser.Parse(input as StreamReader);
//TODO: Display parse errors?
foreach (var decl in tree.Children)
InterpretGlobalProperty(decl, target);
}
else if (input is SDLObject)
foreach (var decl in (input as SDLObject).Children)
InterpretGlobalProperty(decl, target);
else
throw new ArgumentException("input");
}
protected override void Read(DubProject target, Object input, List <Object> subPackages)
{
var json = input as JSONObject;
if (input is TextReader)
{
json = new JSONThingDeserializer().Deserialize(input as TextReader);
}
else if (json == null)
{
throw new ArgumentException("input");
}
foreach (var kv in json.Properties)
{
TryPopulateProperty(target, kv.Key, kv.Value, subPackages);
}
}
public void LoadSubProjects(DubProject defaultPackage, IProgressMonitor monitor)
{
var sln = defaultPackage.ParentSolution;
foreach (var dep in defaultPackage.DubReferences)
{
var file = DubFileReader.GetDubFilePath(defaultPackage, dep.Path);
if (String.IsNullOrWhiteSpace(dep.Path) || !CanLoad(file))
{
continue;
}
var subProject = supportedDubFileFormats.First((i) => i.CanLoad(file)).Load(file, null, sln);
if (defaultPackage != subProject)
{
LoadSubProjects(subProject, monitor);
}
}
}
protected override void Read(DubProject target, Object input, List <Object> subPackagesToBeReadLater)
{
if (input is StreamReader)
{
var tree = SDL.SdlParser.Parse(input as StreamReader);
//TODO: Display parse errors?
foreach (var decl in tree.Children)
{
InterpretGlobalProperty(decl, target);
}
}
else if (input is SDLObject)
{
foreach (var decl in (input as SDLObject).Children)
{
InterpretGlobalProperty(decl, target);
}
}
else
{
throw new ArgumentException("input");
}
}
protected abstract void Read(DubProject target, Object streamReader, List<Object> subPackages);
protected abstract DubProject ReadSubPackage(DubProject superProject, Object definition);
public DubProject Load(string file, DubProject superProject, Solution parentSolution)
{
using (var fs = new FileStream(file, FileMode.Open))
using (var sr = new StreamReader(fs))
return Load(superProject, parentSolution, sr, file);
}
protected void IntroduceConfiguration(DubProject prj, DubProjectConfiguration projectConfiguration)
{
prj.Configurations.Add (projectConfiguration);
}
void InterpretGlobalProperty(SDLDeclaration decl, DubProject target)
{
switch (decl.Name.ToLower())
{
case "displayname":
target.Name = ExtractFirstAttribute(decl);
break;
case "name":
target.packageName = ExtractFirstAttribute(decl);
break;
case "description":
target.Description = ExtractFirstAttribute(decl);
break;
case "homepage":
target.Homepage = ExtractFirstAttribute(decl);
break;
case "authors":
target.Authors.Clear();
target.Authors.AddRange(ExtractUnnamedAttributes(decl));
break;
case "copyright":
target.Copyright = ExtractFirstAttribute(decl);
break;
case "subpackage":
if (decl is SDLObject)
{
base.Load(target, target.ParentSolution, decl, target.FileName);
}
else
{
DubFileManager.Instance.LoadProject(GetDubFilePath(target, ExtractFirstAttribute(decl)), target.ParentSolution, null, DubFileManager.LoadFlags.None, target);
}
break;
case "configuration":
var o = decl as SDLObject;
if (o != null)
{
var c = new DubProjectConfiguration {
Name = ExtractFirstAttribute(o)
};
if (string.IsNullOrEmpty(c.Name))
{
c.Name = "<Undefined>";
}
foreach (var childDecl in o.Children)
{
InterpretBuildSetting(childDecl, c.BuildSettings);
}
IntroduceConfiguration(target, c);
}
break;
case "buildtype":
var name = ExtractFirstAttribute(decl);
if (!string.IsNullOrEmpty(name))
{
target.buildTypes.Add(name);
}
// Ignore remaining contents as they're not needed by mono-d
break;
default:
InterpretBuildSetting(decl, target.CommonBuildSettings);
break;
}
}
protected abstract void Read(DubProject target, Object streamReader, List <Object> subPackages);
public DubProject LoadProject(string file, Solution parentSolution, IProgressMonitor monitor, LoadFlags flags = LoadFlags.LoadReferences, DubProject superProject = null)
{
if(monitor != null)
monitor.BeginTask("Load dub project '" + file + "'", 1);
try
{
var prj = supportedDubFileFormats.First((i) => i.CanLoad(file)).Load(file, superProject, parentSolution);
if (flags.HasFlag(LoadFlags.LoadReferences))
LoadSubProjects(prj, monitor);
return prj;
}
finally
{
if (monitor != null)
monitor.EndTask();
}
}
public DubProject Load(DubProject superPackage, Solution parentSolution, Object streamReader, string originalFile)
{
DubProject defaultPackage;
if(parentSolution == null)
throw new InvalidDataException("Parent solution must be specified!");
bool returnSubProject = superPackage != null;
if (!returnSubProject && (defaultPackage = parentSolution.GetProjectsContainingFile(new FilePath(originalFile)).FirstOrDefault() as DubProject) != null)
{
return defaultPackage;
}
defaultPackage = returnSubProject ? new DubSubPackage() : new DubProject();
defaultPackage.FileName = originalFile;
defaultPackage.BaseDirectory = defaultPackage.FileName.ParentDirectory;
if (returnSubProject)
{
var sub = defaultPackage as DubSubPackage;
sub.OriginalBasePath = superPackage is DubSubPackage ? (superPackage as DubSubPackage).OriginalBasePath :
superPackage.BaseDirectory;
sub.VirtualBasePath = sub.OriginalBasePath;
}
defaultPackage.BeginLoad();
var subPackagesToBeLoadedDeferred = new List<Object> ();
Read(defaultPackage, streamReader, subPackagesToBeLoadedDeferred);
if (defaultPackage.Configurations.Count == 0) {
defaultPackage.Configurations.Add (new DubProjectConfiguration{ Id = DubProjectConfiguration.DefaultConfigId, Name = "Default" });
}
// Set subpackage packageName
if (returnSubProject)
{
defaultPackage.packageName = superPackage.packageName + ":" + (defaultPackage.packageName ?? string.Empty);
var sub = defaultPackage as DubSubPackage;
var sourcePaths = sub.GetSourcePaths().ToArray();
if (sourcePaths.Length > 0 && !string.IsNullOrWhiteSpace(sourcePaths[0]))
sub.VirtualBasePath = new FilePath(sourcePaths[0]);
// TODO: What to do with new configurations that were declared in this sub package? Add them to all other packages as well?
}
// Add package to solution
if (parentSolution is DubSolution)
(parentSolution as DubSolution).AddProject(defaultPackage);
else
parentSolution.RootFolder.AddItem(defaultPackage, false);
// Load subpackages
foreach (var subPackageDeclaration in subPackagesToBeLoadedDeferred) {
ReadSubPackage (defaultPackage, subPackageDeclaration);
}
// Fill dub references
if (defaultPackage.DubReferences.Any(dep => string.IsNullOrWhiteSpace(dep.Path)))
FillDubReferencesPaths(defaultPackage);
else
defaultPackage.DubReferences.FireUpdate();
// Add dub.json/sdl+selections file
if (!returnSubProject)
{
defaultPackage.Items.Add (new ProjectFile (originalFile, BuildAction.None));
// https://github.com/aBothe/Mono-D/issues/555
var dubSelectionJsonPath = defaultPackage.BaseDirectory.Combine (DubSelectionsJsonFile);
if (File.Exists (dubSelectionJsonPath))
defaultPackage.Items.Add (new ProjectFile (dubSelectionJsonPath, BuildAction.None));
}
defaultPackage.EndLoad();
return defaultPackage;
}
void TryPopulateProperty(DubProject prj, string propName, JsonReader j)
{
switch (propName.ToLowerInvariant())
{
case "displayname":
prj.Name = j.ReadAsString();
break;
case "name":
prj.packageName = j.ReadAsString();
break;
case "description":
prj.Description = j.ReadAsString();
break;
case "copyright":
prj.Copyright = j.ReadAsString();
break;
case "homepage":
prj.Homepage = j.ReadAsString();
break;
case "authors":
if (!j.Read() || j.TokenType != JsonToken.StartArray)
throw new JsonReaderException("Expected [ when parsing Authors");
prj.Authors.Clear();
while (j.Read() && j.TokenType != JsonToken.EndArray)
if (j.TokenType == JsonToken.String)
prj.Authors.Add(j.Value as string);
break;
case "dependencies":
if (!j.Read() || j.TokenType != JsonToken.StartObject)
throw new JsonReaderException("Expected { when parsing Authors");
DeserializeDubPrjDependencies(j, prj.CommonBuildSettings);
break;
case "configurations":
if (!j.Read() || j.TokenType != JsonToken.StartArray)
throw new JsonReaderException("Expected [ when parsing Configurations");
var sln = prj.ParentSolution;
if (sln != null && sln.Configurations.Count == 1 && sln.Configurations[0].Id == DubProjectConfiguration.DefaultConfigId)
sln.Configurations.Clear();
if (prj.Configurations.Count == 1 && prj.Configurations[0].Id == DubProjectConfiguration.DefaultConfigId)
prj.Configurations.Clear();
while (j.Read() && j.TokenType != JsonToken.EndArray)
prj.AddProjectAndSolutionConfiguration(DeserializeFromPackageJson(j));
break;
case "subpackages":
if (!j.Read() || j.TokenType != JsonToken.StartArray)
throw new JsonReaderException("Expected [ when parsing subpackages");
while (j.Read() && j.TokenType != JsonToken.EndArray)
ReadSubPackage(prj, j);
break;
case "buildtypes":
if (!j.Read() || j.TokenType != JsonToken.StartObject)
throw new JsonReaderException("Expected [ when parsing build types");
while (j.Read() && j.TokenType != JsonToken.EndObject)
{
var n = j.Value as string;
if (!prj.buildTypes.Contains(n))
prj.buildTypes.Add(n);
j.Skip();
}
prj.buildTypes.Sort();
break;
default:
TryDeserializeBuildSetting(prj.CommonBuildSettings, j);
break;
}
}
public DubProject LoadProject(string file, Solution parentSolution, IProgressMonitor monitor, LoadFlags flags = LoadFlags.LoadReferences, DubProject superProject = null)
{
DubProject prj;
if (FilesBeingLoaded.TryGetValue(file, out prj))
return prj;
using (new FilesBeingLoadedCleanser(file))
{
monitor.BeginTask("Load dub project '" + file + "'", 1);
try
{
prj = supportedDubFileFormats.First((i) => i.CanLoad(file)).Load(file, superProject, parentSolution);
}
catch (Exception ex)
{
monitor.ReportError("Couldn't load dub package \"" + file + "\"", ex);
}
finally
{
monitor.EndTask();
}
if (flags.HasFlag(LoadFlags.LoadReferences))
LoadSubProjects(prj, monitor);
}
return prj;
}
protected void IntroduceConfiguration(DubProject prj, DubProjectConfiguration projectConfiguration)
{
prj.Configurations.Add(projectConfiguration);
}
public DubProject Load(DubProject superPackage, Solution parentSolution, Object streamReader, string originalFile)
{
DubProject defaultPackage;
if (parentSolution == null)
{
throw new InvalidDataException("Parent solution must be specified!");
}
bool returnSubProject = superPackage != null;
if (!returnSubProject && (defaultPackage = parentSolution.GetProjectsContainingFile(new FilePath(originalFile)).FirstOrDefault() as DubProject) != null)
{
return(defaultPackage);
}
defaultPackage = returnSubProject ? new DubSubPackage() : new DubProject();
defaultPackage.FileName = originalFile;
defaultPackage.BaseDirectory = defaultPackage.FileName.ParentDirectory;
if (returnSubProject)
{
var sub = defaultPackage as DubSubPackage;
sub.OriginalBasePath = superPackage is DubSubPackage ? (superPackage as DubSubPackage).OriginalBasePath :
superPackage.BaseDirectory;
sub.VirtualBasePath = sub.OriginalBasePath;
}
defaultPackage.BeginLoad();
var subPackagesToBeLoadedDeferred = new List <Object> ();
Read(defaultPackage, streamReader, subPackagesToBeLoadedDeferred);
if (defaultPackage.Configurations.Count == 0)
{
defaultPackage.Configurations.Add(new DubProjectConfiguration {
Id = DubProjectConfiguration.DefaultConfigId, Name = "Default"
});
}
// Set subpackage packageName
if (returnSubProject)
{
defaultPackage.packageName = superPackage.packageName + ":" + (defaultPackage.packageName ?? string.Empty);
var sub = defaultPackage as DubSubPackage;
var sourcePaths = sub.GetSourcePaths().ToArray();
if (sourcePaths.Length > 0 && !string.IsNullOrWhiteSpace(sourcePaths[0]))
{
sub.VirtualBasePath = new FilePath(sourcePaths[0]);
}
// TODO: What to do with new configurations that were declared in this sub package? Add them to all other packages as well?
}
// Add package to solution
if (parentSolution is DubSolution)
{
(parentSolution as DubSolution).AddProject(defaultPackage);
}
else
{
parentSolution.RootFolder.AddItem(defaultPackage, false);
}
// Load subpackages
foreach (var subPackageDeclaration in subPackagesToBeLoadedDeferred)
{
ReadSubPackage(defaultPackage, subPackageDeclaration);
}
// Fill dub references
if (defaultPackage.DubReferences.Any(dep => string.IsNullOrWhiteSpace(dep.Path)))
{
FillDubReferencesPaths(defaultPackage);
}
else
{
defaultPackage.DubReferences.FireUpdate();
}
// Add dub.json/sdl+selections file
if (!returnSubProject)
{
defaultPackage.Items.Add(new ProjectFile(originalFile, BuildAction.None));
// https://github.com/aBothe/Mono-D/issues/555
var dubSelectionJsonPath = defaultPackage.BaseDirectory.Combine(DubSelectionsJsonFile);
if (File.Exists(dubSelectionJsonPath))
{
defaultPackage.Items.Add(new ProjectFile(dubSelectionJsonPath, BuildAction.None));
}
}
defaultPackage.EndLoad();
return(defaultPackage);
}
void ReadSubPackage(DubProject superProject, JsonReader r)
{
switch (r.TokenType)
{
case JsonToken.StartObject:
Load(superProject, superProject.ParentSolution, r, superProject.FileName);
break;
case JsonToken.String:
DubFileManager.Instance.LoadProject(GetDubFilePath(superProject, r.Value as string), superProject.ParentSolution, null, DubFileManager.LoadFlags.None, superProject);
break;
default:
throw new JsonReaderException("Illegal token on subpackage definition beginning");
}
}
void FillDubReferencesPaths(DubProject prj)
{
string err, outp;
var baseDir = prj.BaseDirectory.ToString();
if (DubListOutputs.TryGetValue(baseDir, out outp))
{
TryInterpretDubListOutput(prj, outp);
}
else
{
try
{
ProjectBuilder.ExecuteCommand(DubSettings.Instance.DubCommand, "list", baseDir, null, out err, out outp);
// Backward compatiblity
if (!string.IsNullOrWhiteSpace(err) || !TryInterpretDubListOutput(prj, outp))
{
ProjectBuilder.ExecuteCommand(DubSettings.Instance.DubCommand, "list-installed", baseDir, null, out err, out outp);
TryInterpretDubListOutput(prj, outp);
}
if (!string.IsNullOrWhiteSpace(outp))
DubListOutputs[baseDir] = outp;
}
catch (Exception ex)
{
LoggingService.LogError("Error while resolving dub dependencies via executing 'dub list-installed'", ex);
}
}
prj.DubReferences.FireUpdate();
}
void InterpretGlobalProperty(SDLDeclaration decl, DubProject target)
{
switch (decl.Name.ToLower())
{
case "displayname":
target.Name = ExtractFirstAttribute(decl);
break;
case "name":
target.packageName = ExtractFirstAttribute(decl);
break;
case "description":
target.Description = ExtractFirstAttribute(decl);
break;
case "homepage":
target.Homepage = ExtractFirstAttribute(decl);
break;
case "authors":
target.Authors.Clear();
target.Authors.AddRange(ExtractUnnamedAttributes(decl));
break;
case "copyright":
target.Copyright = ExtractFirstAttribute(decl);
break;
case "subpackage":
if (decl is SDLObject)
base.Load(target, target.ParentSolution, decl, target.FileName);
else
DubFileManager.Instance.LoadProject(GetDubFilePath(target, ExtractFirstAttribute(decl)), target.ParentSolution, null, DubFileManager.LoadFlags.None, target);
break;
case "configuration":
var o = decl as SDLObject;
if (o != null)
{
var c = new DubProjectConfiguration { Name = ExtractFirstAttribute(o) };
if (string.IsNullOrEmpty(c.Name))
c.Name = "<Undefined>";
foreach (var childDecl in o.Children)
{
InterpretBuildSetting(childDecl, c.BuildSettings);
}
IntroduceConfiguration(target, c);
}
break;
case "buildtype":
var name = ExtractFirstAttribute(decl);
if (!string.IsNullOrEmpty(name))
{
target.buildTypes.Add(name);
}
// Ignore remaining contents as they're not needed by mono-d
break;
default:
InterpretBuildSetting(decl, target.CommonBuildSettings);
break;
}
}
bool TryInterpretDubListOutput(DubProject prj, string outp)
{
if (string.IsNullOrEmpty(outp))
return false;
bool ret = false;
foreach (Match match in dubInstalledPackagesOutputRegex.Matches(outp))
{
ret = true;
if (match.Success)
{
foreach (var kv in prj.DubReferences.GetDependencyEntries())
{
var dep = kv.Value;
if (kv.Key == match.Groups["name"].Value && string.IsNullOrWhiteSpace(dep.Path) &&
(string.IsNullOrEmpty(dep.Version) || CheckRequiredDepVersion(dep.Version, match.Groups["version"].Value)))
{
dep.Path = match.Groups["path"].Value.Trim();
}
}
}
}
return ret;
}
public void LoadSubProjects(DubProject defaultPackage, IProgressMonitor monitor)
{
var sln = defaultPackage.ParentSolution;
foreach (var dep in defaultPackage.DubReferences)
{
var file = DubFileReader.GetDubFilePath(defaultPackage, dep.Path);
if (String.IsNullOrWhiteSpace(dep.Path) || !CanLoad(file))
continue;
var subProject = supportedDubFileFormats.First((i) => i.CanLoad(file)).Load(file, null, sln);
if (defaultPackage != subProject)
{
LoadSubProjects (subProject, monitor);
}
}
}
void TryPopulateProperty(DubProject prj, string propName, JSONThing j, List<Object> subPackages)
{
switch (propName)
{
case "displayname":
prj.Name = ExpectJsonStringValue (j, propName);
break;
case "name":
prj.packageName = ExpectJsonStringValue (j, propName);
break;
case "description":
prj.Description = ExpectJsonStringValue (j, propName);
break;
case "copyright":
prj.Copyright = ExpectJsonStringValue (j, propName);
break;
case "homepage":
prj.Homepage = ExpectJsonStringValue (j, propName);
break;
case "authors":
prj.Authors.Clear();
foreach(var authorValue in ExpectJsonArray(j, propName).Items)
prj.Authors.Add(ExpectJsonStringValue(authorValue, propName));
break;
case "dependencies":
DeserializeDubPrjDependencies(ExpectJsonObject(j, propName), prj.CommonBuildSettings);
break;
case "configurations":
foreach(var o in ExpectJsonArray(j, propName).Items)
IntroduceConfiguration(prj, DeserializeFromPackageJson(ExpectJsonObject(o, propName)));
break;
case "subpackages":
subPackages.AddRange (ExpectJsonArray(j, propName).Items);
break;
case "buildtypes":
foreach (var kv in ExpectJsonObject(j, propName).Properties)
prj.buildTypes.Add (kv.Key);
break;
default:
TryDeserializeBuildSetting(prj.CommonBuildSettings, propName, j);
break;
}
}
protected abstract DubProject ReadSubPackage(DubProject superProject, Object definition);
public void LoadSubProjects(DubProject defaultPackage, IProgressMonitor monitor)
{
var sln = defaultPackage.ParentSolution;
foreach (var dep in defaultPackage.DubReferences)
{
var file = DubFileReader.GetDubFilePath(defaultPackage, dep.Path);
if (String.IsNullOrWhiteSpace(dep.Path) || !CanLoad(file))
continue;
var subProject = supportedDubFileFormats.First((i) => i.CanLoad(file)).Load(file, defaultPackage, sln);
if (sln is DubSolution)
(sln as DubSolution).AddProject(subProject);
else if (sln != null)
sln.RootFolder.AddItem(subProject, false);
else
defaultPackage.packagesToAdd.Add(subProject);
}
}
protected abstract void Read(DubProject target, Object streamReader);
public DubProject LoadProject(string file, Solution parentSolution, IProgressMonitor monitor, LoadFlags flags = LoadFlags.LoadReferences, DubProject superProject = null)
{
if (monitor != null)
{
monitor.BeginTask("Load dub project '" + file + "'", 1);
}
try
{
var prj = supportedDubFileFormats.First((i) => i.CanLoad(file)).Load(file, superProject, parentSolution);
if (flags.HasFlag(LoadFlags.LoadReferences))
{
LoadSubProjects(prj, monitor);
}
return(prj);
}
finally
{
if (monitor != null)
{
monitor.EndTask();
}
}
}
public DubProject Load(string file, DubProject superProject, Solution parentSolution)
{
using (var fs = new FileStream(file, FileMode.Open))
using (var sr = new StreamReader(fs))
return(Load(superProject, parentSolution, sr, file));
}
