public override SaveResult Save(FileModel model)
{
if (model.Type != DocumentType.Article)
{
throw new NotSupportedException();
}
var result = new SaveResult
{
DocumentType = model.DocumentType ?? "Conceptual",
ModelFile = model.File,
LinkToFiles = model.Properties.LinkToFiles,
LinkToUids = ((IEnumerable<string>)model.Properties.LinkToUids).ToDictionary(s => s, s => new HashSet<string> { model.LocalPathFromRepoRoot }).ToImmutableDictionary(),
};
if (model.Properties.XrefSpec != null)
{
result.XRefSpecs = ImmutableArray.Create(model.Properties.XrefSpec);
}
return result;
}
public override SaveResult Save(FileModel model)
{
if (model.Type != DocumentType.Article)
{
throw new NotSupportedException();
}
var result = new SaveResult
{
DocumentType = model.DocumentType ?? "Conceptual",
ModelFile = model.File,
LinkToFiles = model.Properties.LinkToFiles,
LinkToUids = model.Properties.LinkToUids,
};
if (model.Properties.XrefSpec != null)
{
result.XRefSpecs = ImmutableArray.Create(model.Properties.XrefSpec);
}
return result;
}
private static void HandleUids(DocumentBuildContext context, FileModel model, SaveResult result)
{
foreach (var uid in model.Uids)
{
context.UidMap[uid] = ((RelativePath)model.File).GetPathFromWorkingFolder();
}
if (result.LinkToUids.Length > 0)
{
context.XRef.UnionWith(result.LinkToUids);
}
}
private static void CheckFileLink(HostService hostService, FileModel model, SaveResult result)
{
result.LinkToFiles.RunAll(
fileLink =>
{
if (!hostService.SourceFiles.ContainsKey(fileLink))
{
var message = $"Invalid file link({fileLink}) in file \"{model.LocalPathFromRepoRoot}\"";
Logger.LogError(message, file: model.LocalPathFromRepoRoot);
throw new DocumentException(message);
}
});
}
private void HandleSaveResult(
DocumentBuildContext context,
HostService hostService,
FileModel model,
SaveResult result)
{
context.FileMap[((RelativePath)model.OriginalFileAndType.File).GetPathFromWorkingFolder()] = ((RelativePath)model.File).GetPathFromWorkingFolder();
DocumentException.RunAll(
() => CheckFileLink(hostService, model, result),
() => HandleUids(context, model, result),
() => HandleToc(context, result),
() => RegisterXRefSpec(context, model, result),
() => RegisterManifest(context, model, result));
}
public override SaveResult Save(FileModel model)
{
if (model.Type != DocumentType.Article)
{
throw new NotSupportedException();
}
var result = new SaveResult
{
DocumentType = model.DocumentType ?? "Conceptual",
FileWithoutExtension = Path.ChangeExtension(model.File, null),
LinkToFiles = model.LinkToFiles.ToImmutableArray(),
LinkToUids = model.LinkToUids,
FileLinkSources = model.FileLinkSources,
UidLinkSources = model.UidLinkSources,
};
if (model.Properties.XrefSpec != null)
{
result.XRefSpecs = ImmutableArray.Create(model.Properties.XrefSpec);
}
return result;
}
private static InternalManifestItem GetManifestItem(DocumentBuildContext context, FileModel model, SaveResult result)
{
return new InternalManifestItem
{
DocumentType = result.DocumentType,
FileWithoutExtension = result.FileWithoutExtension,
ResourceFile = result.ResourceFile,
Key = model.Key,
LocalPathFromRoot = model.LocalPathFromRoot,
Model = model.ModelWithCache,
InputFolder = model.OriginalFileAndType.BaseDir,
Metadata = new Dictionary<string, object>((IDictionary<string, object>)model.ManifestProperties),
};
}
private void RegisterXRefSpec(DocumentBuildContext context, FileModel model, SaveResult result)
{
foreach (var spec in result.XRefSpecs)
{
if (!string.IsNullOrWhiteSpace(spec?.Uid))
{
XRefSpec xref;
if (context.XRefSpecMap.TryGetValue(spec.Uid, out xref))
{
Logger.LogWarning($"Uid({spec.Uid}) has already been defined in {((RelativePath)xref.Href).RemoveWorkingFolder()}.", file: model.LocalPathFromRepoRoot);
}
else
{
context.XRefSpecMap[spec.Uid] = spec.ToReadOnly();
}
}
}
}
private static void RegisterManifest(DocumentBuildContext context, FileModel model, SaveResult result)
{
context.Manifest.Add(new ManifestItem
{
DocumentType = result.DocumentType,
ModelFile = result.ModelFile,
ResourceFile = result.ResourceFile,
OriginalFile = model.OriginalFileAndType.File,
// TODO: What is API doc's LocalPathToRepo? => defined in ManagedReferenceDocumentProcessor
LocalPathFromRepoRoot = model.LocalPathFromRepoRoot
});
}
private static void CheckFileLink(HostService hostService, SaveResult result)
{
result.LinkToFiles.RunAll(fileLink =>
{
if (!hostService.SourceFiles.ContainsKey(fileLink))
{
ImmutableList<LinkSourceInfo> list;
if (result.FileLinkSources.TryGetValue(fileLink, out list))
{
foreach (var fileLinkSourceFile in list)
{
Logger.LogWarning($"Invalid file link:({fileLinkSourceFile.Target}{fileLinkSourceFile.Anchor}).", null, fileLinkSourceFile.SourceFile, fileLinkSourceFile.LineNumber.ToString());
}
}
else
{
Logger.LogWarning($"Invalid file link:({fileLink}).");
}
}
});
}
private InternalManifestItem HandleSaveResult(
DocumentBuildContext context,
HostService hostService,
FileModel model,
SaveResult result)
{
context.FileMap[model.Key] = ((TypeForwardedToRelativePath)model.File).GetPathFromWorkingFolder();
DocumentException.RunAll(
() => CheckFileLink(hostService, result),
() => HandleUids(context, result),
() => HandleToc(context, result),
() => RegisterXRefSpec(context, result));
return GetManifestItem(context, model, result);
}
public override SaveResult Save(FileModel model)
{
if (model.FileAndType != model.OriginalFileAndType)
{
var targetFile = Path.Combine(model.BaseDir, model.File);
Directory.CreateDirectory(Path.GetDirectoryName(targetFile));
File.Copy(
Path.Combine(model.OriginalFileAndType.BaseDir, model.OriginalFileAndType.File),
targetFile,
true);
File.SetAttributes(targetFile, FileAttributes.Normal);
}
var result = new SaveResult
{
DocumentType = "Resource",
ResourceFile = model.File,
};
if (model.Content != null)
{
// For resources, e.g. image.png, file extension is kept
result.FileWithoutExtension = model.File;
}
return result;
}
public SaveResult Save(FileModel model)
{
if (model.FileAndType != model.OriginalFileAndType)
{
var targetFile = Path.Combine(model.BaseDir, model.File);
Directory.CreateDirectory(Path.GetDirectoryName(targetFile));
File.Copy(
Path.Combine(model.OriginalFileAndType.BaseDir, model.OriginalFileAndType.File),
targetFile,
true);
}
var result = new SaveResult
{
DocumentType = "Resource",
ResourceFile = model.File,
};
if (model.Content != null)
{
var modelFile = model.File.TrimEnd('.') + ".json";
JsonUtility.Serialize(Path.Combine(model.BaseDir, modelFile), model.Content);
result.ModelFile = modelFile;
}
return result;
}
private static void HandleUids(DocumentBuildContext context, FileModel model, SaveResult result)
{
foreach (var uid in model.Uids)
{
context.UidMap[uid] = ((RelativePath)model.File).GetPathFromWorkingFolder();
}
if (result.LinkToUids.Count > 0)
{
foreach(var item in result.LinkToUids)
{
HashSet<string> files;
if (context.XRef.TryGetValue(item.Key, out files))
{
files.UnionWith(item.Value);
}
else
{
context.XRef[item.Key] = item.Value;
}
}
}
}
private static void HandleToc(DocumentBuildContext context, SaveResult result)
{
if (result.TocMap?.Count > 0)
{
foreach (var toc in result.TocMap)
{
HashSet<string> list;
if (context.TocMap.TryGetValue(toc.Key, out list))
{
foreach (var item in toc.Value)
{
list.Add(item);
}
}
else
{
context.TocMap[toc.Key] = toc.Value;
}
}
}
}
private void RegisterXRefSpec(DocumentBuildContext context, FileModel model, SaveResult result)
{
foreach (var spec in result.XRefSpecs)
{
if (!string.IsNullOrWhiteSpace(spec?.Uid))
{
if (context.XRefSpecMap.ContainsKey(spec.Uid))
{
Logger.LogWarning($"Uid({spec.Uid}) duplicated.", file: model.LocalPathFromRepoRoot);
}
else
{
context.XRefSpecMap[spec.Uid] = spec.ToReadOnly();
}
}
}
}
private static void HandleUids(DocumentBuildContext context, SaveResult result)
{
if (result.LinkToUids.Count > 0)
{
context.XRef.UnionWith(result.LinkToUids.Where(s => s != null));
}
}
private void RegisterXRefSpec(DocumentBuildContext context, SaveResult result)
{
foreach (var spec in result.XRefSpecs)
{
if (!string.IsNullOrWhiteSpace(spec?.Uid))
{
XRefSpec xref;
if (context.XRefSpecMap.TryGetValue(spec.Uid, out xref))
{
Logger.LogWarning($"Uid({spec.Uid}) has already been defined in {((TypeForwardedToRelativePath)xref.Href).RemoveWorkingFolder()}.");
}
else
{
context.RegisterInternalXrefSpec(spec);
}
}
}
foreach (var spec in result.ExternalXRefSpecs)
{
if (!string.IsNullOrWhiteSpace(spec?.Uid))
{
context.ReportExternalXRefSpec(spec);
}
}
}
private static void HandleUids(DocumentBuildContext context, FileModel model, SaveResult result)
{
if (result.LinkToUids.Count > 0)
{
context.XRef.UnionWith(result.LinkToUids);
}
}
