public override bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!base.Initialize(rawName, container, context))
{
return(false);
}
if (!J4JSoftware.Roslyn.TargetFramework.CreateTargetFramework(rawName, out var tgtFramework, Logger))
{
return(false);
}
if (!GetProperty <ExpandoObject>(container, "projectReferences", context, out var refContainer, optional: true))
{
return(false);
}
LoadFromContainer <ProjectReference, ExpandoObject>(refContainer, _refCreator, context, out var refList, containerCanBeNull: true);
TargetFramework = tgtFramework.Framework;
TargetVersion = tgtFramework.Version;
ProjectReferences = refList;
return(true);
}
protected virtual bool ValidateInitializationArguments <TContainer>(
string rawName,
TContainer container,
ProjectAssetsContext context,
[CallerMemberName] string callerName = "")
{
if (container == null)
{
Logger.Error($"Undefined {nameof( container )}, {nameof( rawName )} is '{rawName}' (called from {GetCallerPath( callerName )})");
return(false);
}
if (String.IsNullOrEmpty(rawName))
{
Logger.Error($"Undefined or empty {nameof( rawName )} (called from {GetCallerPath( callerName )})");
return(false);
}
if (context == null)
{
Logger.Error($"Undefined or empty {nameof( context )} (called from {GetCallerPath( callerName )})");
return(false);
}
return(true);
}
protected string GetPropertyPath <TContainer>(TContainer toFind, ProjectAssetsContext context)
{
StringBuilder sb = new StringBuilder();
var propertyStack = new Stack <string>();
if (TraverseContainerTree <TContainer>(toFind, context.RootContainer, propertyStack))
{
while (propertyStack.Count > 0)
{
if (sb.Length > 0)
{
sb.Insert(0, "->");
}
sb.Insert(0, propertyStack.Pop());
}
}
if (sb.Length > 0)
{
sb.Insert(0, " [");
sb.Append("]");
}
return(sb.ToString());
}
public virtual bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
return(true);
}
public bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (!VersionedText.CreateVersionedText(rawName, out var verText, Logger))
{
return(false);
}
Assembly = verText.TextComponent;
Version = verText.Version;
Dependencies = new List <DependencyInfo>();
var asDict = (IDictionary <string, object>)container;
// dependencies are optional
if (!asDict.ContainsKey("dependencies"))
{
return(true);
}
var depDict = asDict["dependencies"] as ExpandoObject;
if (depDict == null)
{
Logger.Error(
$"{nameof( container )} does not have a 'dependencies' property which is an {nameof( ExpandoObject )}");
return(false);
}
var retVal = true;
foreach (var kvp in depDict)
{
if (kvp.Value is string versionText)
{
if (VersionedText.TryParseSemanticVersion(versionText, out var version, Logger))
{
var newItem = _diCreator();
newItem.Assembly = kvp.Key;
newItem.Version = version;
Dependencies.Add(newItem);
}
else
{
retVal = false;
}
}
}
public bool Initialize(ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(container, context))
{
return(false);
}
var okay = GetProperty <string>(container, "version", context, out var versionText);
okay &= GetProperty <ExpandoObject>(container, "restore", context, out var restoreContainer);
okay &= GetProperty <ExpandoObject>(container, "frameworks", context, out var frameContainer);
okay &= GetProperty <ExpandoObject>(container, "warningProperties", context, out var warnContainer,
optional: true);
if (!okay)
{
return(false);
}
if (!VersionedText.TryParseSemanticVersion(versionText, out var version, Logger))
{
return(false);
}
var restore = _restoreCreator();
if (!restore.Initialize(restoreContainer, context))
{
return(false);
}
if (!LoadFromContainer <FrameworkReferences, ExpandoObject>(frameContainer, _fwCreator, context,
out var fwList))
{
return(false);
}
LoadFromContainer <WarningProperty, List <string> >(warnContainer, _wpCreator, context, out var warnList,
containerCanBeNull: true);
Version = version;
Restore = restore;
Frameworks = fwList;
WarningProperties = warnList;
return(true);
}
public bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (!GetProperty <string>(container, "privateAssets", context, out var privateAssets))
{
return(false);
}
LibraryName = rawName;
PrivateAssets = privateAssets;
return(true);
}
public bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (!GetProperty <string>(container, "projectPath", context, out var path))
{
return(false);
}
ProjectName = rawName;
ProjectPath = path;
return(true);
}
public bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (!TargetFramework.CreateTargetFramework(rawName, out var tgtFramework, Logger))
{
return(false);
}
Target = tgtFramework.Framework;
Version = tgtFramework.Version;
Packages = new List <ReferenceInfo>();
var retVal = true;
foreach (var kvp in container)
{
var newItem = _refCreator();
if (kvp.Value is ExpandoObject childContainer)
{
if (newItem.Initialize(kvp.Key, childContainer, context))
{
Packages.Add(newItem);
}
else
{
retVal = false;
}
}
else
{
Logger.Error($"{kvp.Key} property is not a {nameof( ExpandoObject )}");
retVal = false;
}
}
return(retVal);
}
public virtual bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (!VersionedText.CreateVersionedText(rawName, out var verText, Logger))
{
return(false);
}
if (!GetProperty <string>(container, "type", context, out var libTypeText))
{
return(false);
}
if (!Enum.TryParse <ReferenceType>(libTypeText, true, out var libType))
{
Logger.Error(
$"Property 'type' ('{libTypeText}') isn't parseable to a {nameof( ReferenceType )}");
return(false);
}
if (libType != Type)
{
Logger.Error($"Expected a {Type} library, encountered a {libType} instead");
return(false);
}
if (!GetProperty <string>(container, "path", context, out var path))
{
return(false);
}
Assembly = verText.TextComponent;
Version = verText.Version;
Path = path;
return(true);
}
public bool Initialize(string rawName, List <string> container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (String.IsNullOrEmpty(rawName))
{
Logger.Error($"Undefined or empty {nameof( rawName )}");
return(false);
}
if (!J4JSoftware.Roslyn.TargetFramework.CreateTargetFramework(rawName, out var tgtFramework, Logger))
{
return(false);
}
TargetFramework = tgtFramework.Framework;
TargetVersion = tgtFramework.Version;
Dependencies = new List <RestrictedDependencyInfo>();
var retVal = true;
foreach (var entry in container)
{
var newItem = _depCreator();
if (newItem.Initialize(entry))
{
Dependencies.Add(newItem);
}
else
{
retVal = false;
}
}
return(retVal);
}
public bool Initialize(string rawName, List <string> container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
WarningType warnType;
if (!Enum.TryParse <WarningType>(rawName, true, out warnType))
{
Logger.Error($"Couldn't parse '{rawName}' as a {nameof(WarningType)}");
return(false);
}
WarningType = warnType;
Codes = container;
return(true);
}
public virtual bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(rawName, container, context))
{
return(false);
}
if (!GetProperty <string>(container, "target", context, out var tgtTypeText))
{
return(false);
}
if (!Enum.TryParse <ReferenceType>(tgtTypeText, true, out var tgtType))
{
Logger.Error($"Couldn't parse '{tgtTypeText}' to a {nameof(ReferenceType)}");
return(false);
}
Assembly = rawName;
TargetType = tgtType;
// parse into individual version strings
rawName = rawName.Replace("[", "")
.Replace(")", "")
.Replace(" ", "");
var versionTexts = rawName.Split(',', StringSplitOptions.RemoveEmptyEntries);
Versions = new List <SemanticVersion>();
var retVal = true;
foreach (var versionText in versionTexts)
{
if (VersionedText.TryParseSemanticVersion(versionText, out var version, Logger))
{
Versions.Add(version);
}
private bool FilterLibraries(ExpandoObject libDict, ReferenceType refType, ProjectAssetsContext context, out ExpandoObject result)
{
result = null;
if (libDict == null)
{
Logger.Error($"Undefined {nameof(libDict)}");
return(false);
}
result = new ExpandoObject();
var allOKay = true;
foreach (var kvp in libDict)
{
if (kvp.Value is ExpandoObject child)
{
if (GetProperty <string>(child, "type", context, out var typeText) &&
Enum.TryParse <ReferenceType>(typeText, true, out var childRefType) &&
childRefType == refType)
{
if (!result.TryAdd(kvp.Key, kvp.Value))
{
Logger.Error($"Couldn't add {kvp.Key} to new {nameof(ExpandoObject)} in {nameof(FilterLibraries)}");
allOKay = false;
}
}
}
}
if (!allOKay)
{
result = null;
}
return(allOKay);
}
public override bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!base.Initialize(rawName, container, context))
{
return(false);
}
var okay = GetProperty <string>(container, "SHA512", context, out var sha512);
okay &= GetProperty <string>(container, "path", context, out var path);
okay &= GetProperty <List <string> >(container, "files", context, out var files);
if (!okay)
{
return(false);
}
SHA512 = sha512;
Files = files;
return(true);
}
public override bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!base.Initialize(rawName, container, context))
{
return(false);
}
if (!GetProperty <string>(container, "msbuildProject", context, out var rawPath))
{
return(false);
}
var projPath = System.IO.Path.GetFullPath(System.IO.Path.Combine(context.ProjectDirectory, rawPath));
if (!IsFileSupported(projPath))
{
return(false);
}
ProjectFilePath = projPath;
return(ParseProjectFile());
}
protected bool LoadFromContainer <TItem, TContainer>(
ExpandoObject container,
Func <TItem> itemCreator,
ProjectAssetsContext context,
out List <TItem> result,
bool containerCanBeNull = false,
[CallerMemberName] string callerName = "")
where TItem : IInitializeFromNamed <TContainer>
{
if (container == null)
{
result = null;
if (containerCanBeNull)
{
return(true);
}
Logger.Error($"Undefined {nameof( container )} (called from {GetCallerPath( callerName )})");
return(false);
}
result = new List <TItem>();
var isOkay = true;
foreach (var kvp in container)
{
if (kvp.Value is TContainer childContainer)
{
var newItem = itemCreator();
if (newItem.Initialize(kvp.Key, childContainer, context))
{
result.Add(newItem);
}
else
{
isOkay = false;
}
}
else
{
// empty json arrays are always List<object>...which likely won't be the type of
// list defined by TContainer. so check for that case
if (kvp.Value is List <object> objArray && (objArray.Count <= 0))
{
continue;
}
Logger.Error(
$"{kvp.Key} property is not a {nameof(ExpandoObject)} (called from {GetCallerPath( callerName )}){GetPropertyPath( container, context )}");
isOkay = false;
}
}
// wipe out collection if something went wrong
if (!isOkay)
{
result = null;
}
return(isOkay);
}
protected bool GetProperty <TProp>(
ExpandoObject container,
string propName,
ProjectAssetsContext context,
out TProp result,
bool caseSensitive = false,
bool optional = false,
[CallerMemberName] string callerName = "")
{
if (container == null)
{
Logger.Error(
$"Undefined {nameof(container)} (called from {GetCallerPath( callerName )})");
result = default;
return(false);
}
if (String.IsNullOrEmpty(propName))
{
Logger.Error(
$"Undefined/empty {nameof(propName)} (called from {GetCallerPath( callerName )}){GetPropertyPath( container, context )}");
result = default;
return(false);
}
var asDict = (IDictionary <string, object>)container;
// ExpandoObject keys are always case sensitive...so if we want a case insensitive match we have to
// go a bit convoluted...
bool hasKey = false;
if (caseSensitive)
{
hasKey = asDict.ContainsKey(propName);
}
else
{
// case insensitive matches
switch (asDict.Keys.Count(k => k.Equals(propName, StringComparison.OrdinalIgnoreCase)))
{
case 0:
// no match; key not found so default value of hasKey is okay
break;
case 1:
// replace the case-insensitive property name with the correctly-cased value
propName = asDict.Keys.First(k => k.Equals(propName, StringComparison.OrdinalIgnoreCase));
hasKey = true;
break;
default:
// multiple case-insensitive matches; case insensitive doesn't work
Logger.Error(
$"Multiple matching property names in {nameof(ExpandoObject)} for property name '{propName}' (called from {GetCallerPath( callerName )})");
break;
}
}
if (!hasKey)
{
result = default;
var mesg =
$"{nameof(container)} doesn't contain a {propName} property (called from {GetCallerPath( callerName )}){GetPropertyPath( container, context )}";
// it's okay if optional properties don't exist
if (optional)
{
Logger.Information(mesg);
return(true);
}
Logger.Error(mesg);
return(false);
}
if (asDict[propName] is TProp retVal)
{
result = retVal;
return(true);
}
Logger.Error(
$"The {propName} property is not a {typeof(TProp).Name} (called from {GetCallerPath( callerName )})");
result = default;
return(false);
}
public bool Initialize(string projFilePath, string projectAssetsPath)
{
if (String.IsNullOrEmpty(projectAssetsPath))
{
Logger.Error($"Empty or undefined {projectAssetsPath}");
return(false);
}
if (!File.Exists(projectAssetsPath))
{
Logger.Error($"File '{projectAssetsPath}' not accessible");
return(false);
}
var opt = new JsonSerializerOptions();
opt.Converters.Add(_paConverter);
ExpandoObject container;
try
{
container = JsonSerializer.Deserialize <ExpandoObject>(File.ReadAllText(projectAssetsPath), opt);
}
catch (Exception e)
{
Logger.Error(e.Message);
return(false);
}
var context = new ProjectAssetsContext
{
ProjectAssetsJsonPath = projectAssetsPath,
ProjectPath = projFilePath,
RootContainer = container
};
var okay = GetProperty <ExpandoObject>(container, "targets", context, out var tgtDict);
okay &= GetProperty <ExpandoObject>(container, "libraries", context, out var libDict);
okay &= GetProperty <ExpandoObject>(container, "projectFileDependencyGroups", context,
out var projFileDepDict);
okay &= GetProperty <ExpandoObject>(container, "packageFolders", context, out var pkgDict);
okay &= GetProperty <ExpandoObject>(container, "project", context, out var projDict);
okay &= GetProperty <int>(container, "version", context, out var version);
if (!okay)
{
return(false);
}
// separate the libraries into package libraries and project libraries so we can process
// them separately
if (!FilterLibraries(libDict, ReferenceType.Package, context, out var pkgLibDict))
{
return(false);
}
if (!FilterLibraries(libDict, ReferenceType.Project, context, out var projLibDict))
{
return(false);
}
var project = _projCreator();
okay = LoadFromContainer <TargetInfo, ExpandoObject>(tgtDict, _tgtCreator, context, out var tgtList);
okay &= LoadFromContainer <PackageLibrary, ExpandoObject>(pkgLibDict, _pkgLibCreator, context,
out var pkgLibList);
okay &= LoadFromContainer <ProjectLibrary, ExpandoObject>(projLibDict, _projLibCreator, context,
out var projLibList);
okay &= LoadFromContainer <ProjectFileDependencyGroup, List <string> >(projFileDepDict, _pfdgCreator, context,
out var pfdgList);
okay &= LoadNamesFromContainer(pkgDict, out var pkgList);
okay &= project.Initialize(projDict, context);
if (!okay)
{
return(false);
}
var projLib = _projLibCreator();
if (!projLib.InitializeFromProjectFile(projFilePath))
{
return(false);
}
Version = version;
Targets = tgtList;
Libraries = new List <ILibraryInfo>();
Libraries.AddRange(pkgLibList);
Libraries.AddRange(projLibList);
ProjectFileDependencyGroups = pfdgList;
Project = project;
PackageFolders = pkgList;
ProjectLibrary = projLib;
return(true);
}
public override bool Initialize(string rawName, ExpandoObject container, ProjectAssetsContext context)
{
if (!base.Initialize(rawName, container, context))
{
return(false);
}
if (!J4JSoftware.Roslyn.TargetFramework.CreateTargetFramework(rawName, out var tgtFramework, Logger))
{
return(false);
}
var okay = GetProperty <ExpandoObject>(container, "dependencies", context, out var depContainer);
okay &= GetProperty <List <string> >(container, "imports", context, out var importTexts);
okay &= GetProperty <ExpandoObject>(container, "frameworkReferences", context, out var fwContainer);
okay &= GetProperty <bool>(container, "assetTargetFallback", context, out var fallback);
okay &= GetProperty <bool>(container, "warn", context, out var warn);
okay &= GetProperty <string>(container, "runtimeIdentifierGraphPath", context, out var rtGraph);
if (!okay)
{
return(false);
}
okay = LoadFromContainer <DependencyList, ExpandoObject>(depContainer, _depListCreator, context,
out var depList);
okay &= LoadFromContainer <FrameworkLibraryReference, ExpandoObject>(fwContainer, _fwlCreator, context,
out var fwList);
if (!okay)
{
return(false);
}
var importsValid = true;
var imports = importTexts.Select(it =>
{
if (!J4JSoftware.Roslyn.TargetFramework.CreateTargetFramework(it, out var retVal, Logger))
{
importsValid = false;
return(null);
}
return(retVal);
})
.ToList();
if (!importsValid)
{
return(false);
}
TargetFramework = tgtFramework.Framework;
TargetVersion = tgtFramework.Version;
Dependencies = depList;
Imports = imports;
AssetTargetFallback = fallback;
Warn = warn;
FrameworkLibraryReferences = fwList;
RuntimeIdentifierGraphPath = rtGraph;
return(true);
}
public bool Initialize(ExpandoObject container, ProjectAssetsContext context)
{
if (!ValidateInitializationArguments(container, context))
{
return(false);
}
var okay = GetProperty <string>(container, "projectStyle", context, out var styleText);
okay &= GetProperty <string>(container, "projectUniqueName", context, out var uniqueName);
okay &= GetProperty <string>(container, "projectName", context, out var projName);
okay &= GetProperty <string>(container, "projectPath", context, out var path);
okay &= GetProperty <string>(container, "packagesPath", context, out var pkgPath, optional: true);
okay &= GetProperty <string>(container, "outputPath", context, out var outPath);
okay &= GetProperty <List <string> >(container, "fallbackFolders", context, out var fallbackList,
optional: true);
okay &= GetProperty <List <string> >(container, "configFilePaths", context, out var configPaths,
optional: true);
okay &= GetProperty <List <string> >(container, "originalTargetFrameworks", context, out var origFWText);
okay &= GetProperty <ExpandoObject>(container, "sources", context, out var srcContainer, optional: true);
if (!okay)
{
return(false);
}
if (!Enum.TryParse <ProjectStyle>(styleText, true, out var style))
{
Logger.Error($"Couldn't parse projectStyle text '{styleText}' as a {nameof(ProjectStyle)}");
return(false);
}
var origFWValid = true;
var tgtFrameworks = origFWText.Select(t =>
{
if (TargetFramework.CreateTargetFramework(t, out var retVal, Logger))
{
return(retVal);
}
origFWValid = false;
return(null);
})
.ToList();
if (!origFWValid)
{
return(false);
}
List <string> sources = null;
if (srcContainer != null && !LoadNamesFromContainer(srcContainer, out sources))
{
return(false);
}
ProjectStyle = style;
ProjectUniqueName = uniqueName;
ProjectName = projName;
ProjectPath = path;
PackagesPath = pkgPath;
OriginalTargetFrameworks = tgtFrameworks;
OutputPath = outPath;
FallbackFolders = fallbackList;
ConfigurationFilePaths = configPaths;
Sources = sources;
return(true);
}
