public override ProcessingPriority GetProcessingPriority(FileAndType file)
{
switch (file.Type)
{
case DocumentType.Article:
if (".yml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase) ||
".yaml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
var mime = YamlMime.ReadMime(file.File);
switch (mime)
{
case Constants.JavaScriptReferenceYamlMime:
return(ProcessingPriority.Normal);
default:
return(ProcessingPriority.NotSupported);
}
}
break;
case DocumentType.Overwrite:
if (".md".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
return(ProcessingPriority.Normal);
}
break;
}
return(ProcessingPriority.NotSupported);
}
public override ProcessingPriority GetProcessingPriority(FileAndType file)
{
switch (file.Type)
{
case DocumentType.Article:
if (".yml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase) ||
".yaml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
var mime = YamlMime.ReadMime(file.File);
if (string.Equals(mime, YamlMime.YamlMimePrefix + _schemaName))
{
return(ProcessingPriority.Normal);
}
return(ProcessingPriority.NotSupported);
}
break;
case DocumentType.Overwrite:
if (_allowOverwrite && ".md".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
return(ProcessingPriority.Normal);
}
break;
default:
break;
}
return(ProcessingPriority.NotSupported);
}
public override ProcessingPriority GetProcessingPriority(FileAndType file)
{
switch (file.Type)
{
case DocumentType.Article:
if (".yml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase) ||
".yaml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
var mime = YamlMime.ReadMime(file.File);
if (string.Equals(mime, YamlMime.YamlMimePrefix + _schemaName))
{
return(ProcessingPriority.Normal);
}
return(ProcessingPriority.NotSupported);
}
break;
// temporarily disable loading of overwrite documents in SDP
// TODO: reenable processing of overwrite documents in SDP
//case DocumentType.Overwrite:
// if (".md".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
// {
// return ProcessingPriority.Normal;
// }
// break;
default:
break;
}
return(ProcessingPriority.NotSupported);
}
public void TestBoolean()
{
var sw = new StringWriter();
YamlUtility.Serialize(sw, new object[] { true, false }, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
var yaml = sw.ToString();
Assert.Equal(@"### YamlMime:Test-Yaml-Mime
- true
- false
".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
var value = YamlUtility.Deserialize <object[]>(new StringReader(yaml));
Assert.NotNull(value);
Assert.Equal(2, value.Length);
Assert.Equal(true, value[0]);
Assert.Equal(false, value[1]);
var value2 = YamlUtility.Deserialize <object[]>(new StringReader(@"### YamlMime:Test-Yaml-Mime
- true
- True
- TRUE
- false
- False
- FALSE
"));
Assert.NotNull(value2);
Assert.Equal(new[] { true, true, true, false, false, false }, value2.Cast <bool>());
}
public void TestYamlMime_Success()
{
var sw = new StringWriter();
YamlUtility.Serialize(sw, 1, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
var yaml = sw.ToString();
Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
}
public void TestYamlMime_NoYamlMime()
{
var sw = new StringWriter();
YamlUtility.Serialize(sw, 1, "No-Yaml-Mime");
var yaml = sw.ToString();
Assert.Null(YamlMime.ReadMime(new StringReader(yaml)));
}
private static void ProcessFilePair(string ymlInputFile, string ymlOutputFile, string mdFile, Dictionary <string, DocumentSchema> schemas)
{
var yamlStream = new YamlStream();
using (var sr = new StreamReader(ymlInputFile))
{
yamlStream.Load(sr);
}
if (yamlStream.Documents.Count != 1)
{
throw new NotSupportedException("Does not support mutiple YAML documents");
}
var mime = YamlMime.ReadMime(ymlInputFile);
if (string.IsNullOrEmpty(mime))
{
Console.WriteLine("Cannot find MIME in {0}", ymlInputFile);
return;
}
var schemaName = mime.Substring(YamlMime.YamlMimePrefix.Length);
if (!schemas.ContainsKey(schemaName))
{
Console.WriteLine("Schema {0} not found", schemaName);
return;
}
var schema = schemas[schemaName];
var mdFragments = FragmentModelHelper.LoadMarkdownFragment(mdFile);
_iterator.Traverse(yamlStream.Documents[0].RootNode, mdFragments, schema);
var validFragments = mdFragments.Values.Where(v => v.Properties?.Count > 0).ToList();
if (validFragments.Count > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var fragment in validFragments)
{
sb.AppendLine(fragment.ToString());
}
var mdFolder = Path.GetDirectoryName(mdFile);
if (!Directory.Exists(mdFolder))
{
Directory.CreateDirectory(mdFolder);
}
File.WriteAllText(mdFile, sb.ToString());
var ymlFolder = Path.GetDirectoryName(ymlOutputFile);
if (!Directory.Exists(ymlFolder))
{
Directory.CreateDirectory(ymlFolder);
}
YamlUtility.Serialize(ymlOutputFile, yamlStream.Documents[0].RootNode, mime);
}
}
public static void SetSchemaName(MarkdownDocument document)
{
// TODO: add this detection logic in terms of performance optimization, should remove once mime is available in context
if (InclusionContext.IsInclude &&
(string.Equals(Path.GetExtension(InclusionContext.RootFile?.ToString()), ".yml", StringComparison.OrdinalIgnoreCase) ||
string.Equals(Path.GetExtension(InclusionContext.RootFile?.ToString()), ".yaml", StringComparison.OrdinalIgnoreCase)))
{
var schemaName = YamlMime.ReadMime(InclusionContext.RootFile?.ToString());
if (!string.IsNullOrEmpty(schemaName))
{
document.SetData("SchemaName", schemaName);
}
}
}
protected override FileModel LoadArticle(FileAndType file, ImmutableDictionary <string, object> metadata)
{
if (YamlMime.ReadMime(file.File) == null)
{
Logger.LogWarning(
"Please add yamlmime in the first line of file, e.g.: `### YamlMime:ManagedReference`, we will decline yaml files without yamlmime in next release.",
file: file.File,
code: WarningCodes.Yaml.MissingYamlMime);
}
var page = YamlUtility.Deserialize <PageViewModel>(file.File);
if (page.Items == null || page.Items.Count == 0)
{
return(null);
}
if (page.Metadata == null)
{
page.Metadata = metadata.ToDictionary(p => p.Key, p => p.Value);
}
else
{
foreach (var item in metadata)
{
if (!page.Metadata.ContainsKey(item.Key))
{
page.Metadata[item.Key] = item.Value;
}
}
}
page.Metadata[Constants.PropertyName.SystemKeys] = SystemKeys;
var localPathFromRoot = PathUtility.MakeRelativePath(EnvironmentContext.BaseDirectory, EnvironmentContext.FileAbstractLayer.GetPhysicalPath(file.File));
return(new FileModel(file, page, serializer: new BinaryFormatter())
{
Uids = (from item in page.Items select item.Uid)
.Concat(from item in page.Items where item.Overload != null select item.Overload)
.Distinct().Select(s => new UidDefinition(s, localPathFromRoot)).ToImmutableArray(),
LocalPathFromRoot = localPathFromRoot
});
}
public override ProcessingPriority GetProcessingPriority(FileAndType file)
{
switch (file.Type)
{
case DocumentType.Article:
if (".yml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase) ||
".yaml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
var mime = YamlMime.ReadMime(Path.Combine(file.BaseDir, file.File));
switch (mime)
{
case YamlMime.ManagedReference:
return(ProcessingPriority.Normal);
case null:
return(ProcessingPriority.BelowNormal);
default:
return(ProcessingPriority.NotSupported);
}
}
if (".csyml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase) ||
".csyaml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
return(ProcessingPriority.Normal);
}
break;
case DocumentType.Overwrite:
if (".md".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
return(ProcessingPriority.Normal);
}
break;
default:
break;
}
return(ProcessingPriority.NotSupported);
}
public void TestBasicClass()
{
var sw = new StringWriter();
YamlUtility.Serialize(sw, new BasicClass {
B = 1, C = "Good!"
}, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
var yaml = sw.ToString();
Assert.Equal(@"### YamlMime:Test-Yaml-Mime
B: 1
C: Good!
".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
var value = YamlUtility.Deserialize <BasicClass>(new StringReader(yaml));
Assert.NotNull(value);
Assert.Equal(1, value.B);
Assert.Equal("Good!", value.C);
}
public override ProcessingPriority GetProcessingPriority(FileAndType file)
{
if (file.Type != DocumentType.Article)
{
return(ProcessingPriority.NotSupported);
}
if (!".yml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase) &&
!".yaml".Equals(Path.GetExtension(file.File), StringComparison.OrdinalIgnoreCase))
{
return(ProcessingPriority.NotSupported);
}
var mime = YamlMime.ReadMime(file.File);
switch (mime)
{
case YamlDocumentYamlMime:
return(ProcessingPriority.Normal);
default:
return(ProcessingPriority.NotSupported);
}
}
public void TestBigInteger()
{
var sw = new StringWriter();
YamlUtility.Serialize(sw, new object[] { 1234567890000L, 9876543210000L, long.MaxValue, ulong.MaxValue }, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
var yaml = sw.ToString();
Assert.Equal(@"### YamlMime:Test-Yaml-Mime
- 1234567890000
- 9876543210000
- 9223372036854775807
- 18446744073709551615
".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
var value = YamlUtility.Deserialize <object[]>(new StringReader(yaml));
Assert.NotNull(value);
Assert.Equal(4, value.Length);
Assert.Equal(1234567890000L, value[0]);
Assert.Equal(9876543210000L, value[1]);
Assert.Equal(long.MaxValue, value[2]);
Assert.Equal(ulong.MaxValue, value[3]);
}
