mirror of
https://github.com/Nioux/AideDeJeu.git
synced 2025-10-30 23:16:09 +00:00
748 lines
30 KiB
C#
748 lines
30 KiB
C#
using AideDeJeu.Tools;
|
|
using AideDeJeu.ViewModels;
|
|
using AideDeJeuLib;
|
|
using Markdig;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Runtime.Serialization.Json;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using Xamarin.Forms;
|
|
using YamlDotNet.Serialization;
|
|
using YamlDotNet.Serialization.NamingConventions;
|
|
|
|
namespace AideDeJeuCmd
|
|
{
|
|
class Program
|
|
{
|
|
|
|
//static async Task<IEnumerable<Spell>> TestMarkdown(string filename)
|
|
//{
|
|
// using (var sr = new StreamReader(filename))
|
|
// {
|
|
// var md = await sr.ReadToEndAsync();
|
|
// var document = Markdig.Parsers.MarkdownParser.Parse(md);
|
|
// //DumpMarkdownDocument(document);
|
|
|
|
// var spellss = document.ToSpells<SpellHD>();
|
|
// Console.WriteLine("ok");
|
|
// var md2 = spellss.ToMarkdownString();
|
|
// if (md.CompareTo(md2) != 0)
|
|
// {
|
|
// Debug.WriteLine("failed");
|
|
// }
|
|
// return spellss;
|
|
// }
|
|
//}
|
|
|
|
static async Task<IEnumerable<Monster>> TestMarkdownMonsters(string filename)
|
|
{
|
|
using (var sr = new StreamReader(filename))
|
|
{
|
|
var md = await sr.ReadToEndAsync();
|
|
var pipeline = new MarkdownPipelineBuilder()
|
|
.UseYamlFrontMatter()
|
|
.UsePipeTables()
|
|
.Build();
|
|
//var document = Markdig.Parsers.MarkdownParser.Parse(md, pipeline);
|
|
//DumpMarkdownDocument(document);
|
|
var monsters = DependencyService.Get<StoreViewModel>().ToItem(filename, md, null) as IEnumerable<Monster>; // document.ToMonsters<MonsterHD>();
|
|
//document.Dump();
|
|
Console.WriteLine("ok");
|
|
//var md2 = monsters.ToMarkdownString();
|
|
//if (md.CompareTo(md2) != 0)
|
|
//{
|
|
// Debug.WriteLine("failed");
|
|
//}
|
|
return monsters;
|
|
}
|
|
}
|
|
|
|
static async Task CreateIndexes()
|
|
{
|
|
string dataDir = @"..\..\..\..\..\Data\";
|
|
|
|
var result = string.Empty;
|
|
var md = await LoadStringAsync(dataDir + "spells_hd.md");
|
|
var items = DependencyService.Get<StoreViewModel>().ToItem("spells_hd", md, null) as IEnumerable<Spell>;
|
|
|
|
var classes = new string[]
|
|
{
|
|
"Barde",
|
|
"Clerc",
|
|
"Druide",
|
|
"Ensorceleur",
|
|
"Magicien",
|
|
"Paladin",
|
|
"Rôdeur",
|
|
"Sorcier"
|
|
};
|
|
var levels = new string[]
|
|
{
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9",
|
|
//"tour de magie",
|
|
//"niveau 1",
|
|
//"niveau 2",
|
|
//"niveau 3",
|
|
//"niveau 4",
|
|
//"niveau 5",
|
|
//"niveau 6",
|
|
//"niveau 7",
|
|
//"niveau 8",
|
|
//"niveau 9"
|
|
};
|
|
foreach (var classe in classes)
|
|
{
|
|
//Console.WriteLine(classe);
|
|
result += string.Format("## {0}\n\n", classe);
|
|
foreach (var level in levels)
|
|
{
|
|
//Console.WriteLine(level);
|
|
var spells = items.Where(s => s.Level == level && s.Source.Contains(classe)).OrderBy(s => s.Name).Select(s => string.Format("* [{0}](spells_hd.md#{1})", s.Name, Helpers.IdFromName(s.Name))).ToList();
|
|
if (spells.Count > 0)
|
|
{
|
|
result += string.Format("### {0}\n\n", level == "0" ? "Tours de magie" : "Niveau " + level);
|
|
result += spells.Aggregate((s1, s2) => s1 + "\n" + s2);
|
|
result += "\n\n";
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine(result);
|
|
await SaveStringAsync(dataDir + "spells_hd_by_class_level.md", result);
|
|
}
|
|
|
|
static async Task<IEnumerable<string>> GetAllAnchorsAsync()
|
|
{
|
|
var anchors = new List<string>();
|
|
var allitems = new Dictionary<string, Item>();
|
|
var names = Helpers.GetResourceNames();
|
|
foreach(var name in names)
|
|
{
|
|
//if (name.Contains("_hd."))
|
|
//{
|
|
var md = await Helpers.GetResourceStringAsync(name);
|
|
var item = DependencyService.Get<StoreViewModel>().ToItem(name, md, null);
|
|
allitems.Add(name, item);
|
|
//}
|
|
}
|
|
foreach(var allitem in allitems)
|
|
{
|
|
if (allitem.Value is Items)
|
|
{
|
|
var items = allitem.Value as Items;
|
|
foreach (var item in await items.GetChildrenAsync())
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(item.Name))
|
|
{
|
|
//Console.WriteLine(item.Name);
|
|
anchors.Add(item.Name);
|
|
}
|
|
}
|
|
}
|
|
else if(allitem.Value != null)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(allitem.Value.Name))
|
|
{
|
|
//Console.WriteLine(allitem.Value.Name);
|
|
anchors.Add(allitem.Value.Name);
|
|
}
|
|
}
|
|
}
|
|
return anchors;
|
|
}
|
|
|
|
static async Task SearchAsync(string anchor)
|
|
{
|
|
var first = true;
|
|
var names = Helpers.GetResourceNames();
|
|
foreach (var name in names)
|
|
{
|
|
if (name.EndsWith("_hd.md"))
|
|
{
|
|
var md = await Helpers.GetResourceStringAsync(name);
|
|
using (var reader = new StringReader(md))
|
|
{
|
|
var line = await reader.ReadLineAsync();
|
|
while (line != null)
|
|
{
|
|
if (line.FirstOrDefault() != '#' &&
|
|
!line.StartsWith("- AltName") &&
|
|
line.Contains(anchor) &&
|
|
!line.Contains($"[{anchor}") &&
|
|
!line.Contains($"{anchor}]")
|
|
)
|
|
{
|
|
if (first)
|
|
{
|
|
first = false;
|
|
Console.WriteLine();
|
|
Console.WriteLine(anchor);
|
|
Console.WriteLine();
|
|
}
|
|
Console.WriteLine(line);
|
|
Console.WriteLine();
|
|
}
|
|
line = await reader.ReadLineAsync();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//Console.WriteLine();
|
|
}
|
|
|
|
static async Task ReorderSpellsAsync()
|
|
{
|
|
string dataDir = @"..\..\..\..\..\Data\";
|
|
var mdVF = await LoadStringAsync(dataDir + "spells_hd.md");
|
|
var mdVO = await LoadStringAsync(dataDir + "spells_vo.md");
|
|
var md = mdVO;
|
|
|
|
StringBuilder mdOut = new StringBuilder();
|
|
using (var writer = new StringWriter(mdOut) { NewLine = "\n" })
|
|
{
|
|
using (var reader = new StringReader(md))
|
|
{
|
|
var line = await reader.ReadLineAsync();
|
|
string levelType = null;
|
|
string castingTime = null;
|
|
string range = null;
|
|
string components = null;
|
|
string duration = null;
|
|
string classes = null;
|
|
string source = null;
|
|
while (line != null)
|
|
{
|
|
if (line.StartsWith("- ") && !line.StartsWith("- AltName:"))
|
|
{
|
|
if (line.StartsWith("- LevelType:"))
|
|
{
|
|
levelType = line;
|
|
}
|
|
else if (line.StartsWith("- **Temps d'incantation :**") || line.StartsWith("- **Casting Time :**"))
|
|
{
|
|
castingTime = line;
|
|
}
|
|
else if (line.StartsWith("- **Portée :**") || line.StartsWith("- **Range :**"))
|
|
{
|
|
range = line;
|
|
}
|
|
else if (line.StartsWith("- **Composantes :**") || line.StartsWith("- **Components :**"))
|
|
{
|
|
components = line;
|
|
}
|
|
else if (line.StartsWith("- **Durée :**") || line.StartsWith("- **Duration :**"))
|
|
{
|
|
duration = line;
|
|
}
|
|
else if (line.StartsWith("- Classes:"))
|
|
{
|
|
classes = line;
|
|
}
|
|
else if (line.StartsWith("- Source:"))
|
|
{
|
|
source = line;
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(line);
|
|
Console.ReadLine();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(levelType != null)
|
|
{
|
|
await writer.WriteLineAsync(levelType);
|
|
if(castingTime != null) await writer.WriteLineAsync(castingTime);
|
|
if(range != null) await writer.WriteLineAsync(range);
|
|
if(components != null) await writer.WriteLineAsync(components);
|
|
if(duration != null) await writer.WriteLineAsync(duration);
|
|
if(classes != null) await writer.WriteLineAsync(classes);
|
|
if(source != null) await writer.WriteLineAsync(source);
|
|
levelType = null;
|
|
castingTime = null;
|
|
range = null;
|
|
components = null;
|
|
duration = null;
|
|
classes = null;
|
|
source = null;
|
|
}
|
|
await writer.WriteLineAsync(line);
|
|
}
|
|
line = await reader.ReadLineAsync();
|
|
}
|
|
}
|
|
}
|
|
await SaveStringAsync(dataDir + "spells_vo_rev.md", mdOut.ToString());
|
|
Console.Write(mdOut);
|
|
Console.ReadLine();
|
|
}
|
|
|
|
|
|
static string inDir = @"..\..\..\..\..\Data\";
|
|
|
|
public static async Task PreloadAllItemsFromFilesAsync(StoreViewModel store)
|
|
{
|
|
foreach (var fileName in Directory.GetFiles(inDir, "*.md", new EnumerationOptions() { MatchType = MatchType.Simple, RecurseSubdirectories = false }))
|
|
{
|
|
//foreach (var resourceName in Tools.Helpers.GetResourceNames())
|
|
//{
|
|
var shortName = fileName.Substring(inDir.Length);
|
|
var regex = new Regex(@"(?<name>.*?)\.md");
|
|
var match = regex.Match(shortName);
|
|
var source = match.Groups["name"].Value;
|
|
if (!string.IsNullOrEmpty(source))
|
|
{
|
|
if (!store._AllItems.ContainsKey(source))
|
|
{
|
|
//ar md = await AideDeJeu.Tools.Helpers.GetResourceStringAsync(resourceName);
|
|
var md = await File.ReadAllTextAsync(fileName);
|
|
if (md != null)
|
|
{
|
|
var item = store.ToItem(source, md, store._AllItems);
|
|
if (item != null)
|
|
{
|
|
var anchors = new Dictionary<string, Item>();
|
|
//MakeAnchors(source, anchors, item);
|
|
item.RootId = $"{source}.md";
|
|
store._AllItems[source] = item;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static string outDir = @"..\..\..\..\..\Data\HD\";
|
|
|
|
static async Task Main(string[] args)
|
|
{
|
|
Tests.Xamarin.Forms.Mocks.MockForms.Init();
|
|
SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_e_sqlite3());
|
|
DependencyService.Register<INativeAPI, AideDeJeu.Cmd.Version_CMD>();
|
|
//var store = new StoreViewModel();
|
|
//await store.GetItemFromDataAsync("test", "truc");
|
|
|
|
var store = new StoreViewModel();
|
|
//await store.PreloadAllItemsAsync();
|
|
await PreloadAllItemsFromFilesAsync(store);
|
|
|
|
var index = store._AllItems.Where(it => it.Value.RootId == "index.md").FirstOrDefault();
|
|
index.Value.Id = index.Value.RootId;
|
|
index.Value.Name = "Bibliothèque";
|
|
|
|
using (var context = await StoreViewModel.GetLibraryContextAsync())
|
|
{
|
|
await context.Database.EnsureDeletedAsync();
|
|
await context.Database.EnsureCreatedAsync();
|
|
|
|
await context.Items.AddRangeAsync(store._AllItems.Values);
|
|
await context.SaveChangesAsync();
|
|
|
|
var itemsSRD = await context.Items.Where(item => (item.Source != null && item.Source.Contains("SRD"))).ToListAsync();
|
|
var monsters = await context.Monsters.ToListAsync();
|
|
var monstersHD = await context.MonstersHD.ToListAsync();
|
|
var monstersVO = await context.MonstersVO.ToListAsync();
|
|
var spells = await context.Spells.ToListAsync();
|
|
|
|
//var item1 = monsters.FirstOrDefault();
|
|
|
|
//var test1y = item1.Yaml;
|
|
//var test1m = item1.Markdown;
|
|
//var test1ym = item1.YamlMarkdown;
|
|
|
|
//var item2 = Item.ParseYamlMarkdown(test1ym);
|
|
|
|
//var test2y = item2.Yaml;
|
|
//var test2m = item2.Markdown;
|
|
//var test2ym = item2.YamlMarkdown;
|
|
|
|
var items = await context.Items.ToListAsync();
|
|
|
|
var matchids = new Dictionary<string, string>();
|
|
|
|
foreach (var item in await context.Items.ToListAsync())
|
|
{
|
|
matchids[item.Id] = item.NewId;
|
|
if (!string.IsNullOrEmpty(item.RootId))
|
|
{
|
|
matchids[item.RootId] = item.NewId;
|
|
}
|
|
// Helpers.RemoveDiacritics(item.Id).Replace(".md#", "_") + ".md";
|
|
}
|
|
|
|
foreach (var item in await context.Items.ToListAsync())
|
|
{
|
|
//await item.LoadFilteredItemsAsync();
|
|
if(item is Spells)
|
|
{
|
|
int iii = 1;
|
|
}
|
|
var yaml = item.YamlMarkdown;
|
|
//var rx = new Regex(@"\(.*?\.md.*?\)");
|
|
//var matchess = rx.Matches(yaml);
|
|
//foreach (Match match in matchess)
|
|
//{
|
|
// yaml = yaml.Replace(match.Value, matchids[match.Value]);
|
|
//}
|
|
foreach (var matchid in matchids)
|
|
{
|
|
yaml = yaml.Replace($"({matchid.Key})", $"({matchid.Value})");
|
|
}
|
|
var filename = Path.Combine(outDir, WebUtility.UrlEncode(item.NewId));
|
|
if (filename.Contains("%"))
|
|
{
|
|
Console.WriteLine(filename);
|
|
}
|
|
await SaveStringAsync(filename, yaml);
|
|
|
|
var filtervm = item.GetNewFilterViewModel();
|
|
if(filtervm != null)
|
|
{
|
|
foreach(var filter in filtervm.Filters)
|
|
{
|
|
foreach(var kv in filter.KeyValues)
|
|
{
|
|
var key = kv.Key;
|
|
var val = kv.Value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int i = 1;
|
|
|
|
//var serializer = new SerializerBuilder()
|
|
// .WithTagMapping("!MonsterHD", typeof(MonsterHD))
|
|
// .WithTagMapping("!MonsterVO", typeof(MonsterVO))
|
|
// .WithTagMapping("!Monsters", typeof(List<Monster>))
|
|
// .EnsureRoundtrip()
|
|
// .WithNamingConvention(new PascalCaseNamingConvention())
|
|
// .Build();
|
|
//var deserializer = new DeserializerBuilder()
|
|
// .WithTagMapping("!MonsterHD", typeof(MonsterHD))
|
|
// .WithTagMapping("!MonsterVO", typeof(MonsterVO))
|
|
// .WithTagMapping("!Monsters", typeof(List<Monster>))
|
|
// .WithNamingConvention(new PascalCaseNamingConvention())
|
|
// .Build();
|
|
//var yaml = serializer.Serialize(monsters);
|
|
//var sr = new StringReader(yaml);
|
|
//var deser = deserializer.Deserialize(sr);
|
|
|
|
//var truc = Item.ParseYamlMarkdown(monsters.FirstOrDefault().YamlMarkdown);
|
|
//Console.WriteLine(yaml);
|
|
}
|
|
|
|
|
|
return;
|
|
await ReorderSpellsAsync();
|
|
return;
|
|
string dataDir = @"..\..\..\..\..\Data\";
|
|
await CheckAllLinks();
|
|
//var anchors = await GetAllAnchorsAsync();
|
|
//foreach (var anchor in anchors)
|
|
//{
|
|
// await SearchAsync(anchor);
|
|
//}
|
|
Console.ReadLine();
|
|
return;
|
|
var mdVO = await LoadStringAsync(dataDir + "monsters_vo.md");
|
|
var mdVF = await LoadStringAsync(dataDir + "monsters_hd.md");
|
|
|
|
//var regex = new Regex("# (?<namevo>.*?)\n- NameVO: \\[(?<namevf>.*?)\\]\n");
|
|
//var matches = regex.Matches(mdVO);
|
|
//foreach(Match match in matches)
|
|
//{
|
|
// var nameVF = match.Groups["namevf"].Value;
|
|
// var nameVO = match.Groups["namevo"].Value;
|
|
// var replaceOld = string.Format("# {0}\n", nameVF);
|
|
// var replaceNew = string.Format("# {0}\n- NameVO: [{1}](monsters_vo.md#{2})\n", nameVF, nameVO, Helpers.IdFromName(nameVO));
|
|
// mdVF = mdVF.Replace(replaceOld, replaceNew);
|
|
//}
|
|
|
|
var regex = new Regex("_\\[(?<name>.*?)\\]_");
|
|
var matches = regex.Matches(mdVF);
|
|
var names = new List<string>();
|
|
foreach (Match match in matches)
|
|
{
|
|
var name = match.Groups["name"].Value;
|
|
if (!mdVF.Contains($"[{name}]:"))
|
|
{
|
|
//Console.WriteLine(name);
|
|
names.Add(name);
|
|
}
|
|
}
|
|
//names.Sort();
|
|
names = names.OrderBy(n => n).Distinct().ToList();
|
|
foreach (var name in names)
|
|
{
|
|
Console.WriteLine($"[{name}]: spells_hd.md#{Helpers.IdFromName(Helpers.Capitalize(name))}");
|
|
}
|
|
|
|
Console.WriteLine(mdVF);
|
|
//await SaveStringAsync(dataDir + "monsters_hd_tmp.md", mdVF);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
public static async Task CheckAllLinks()
|
|
{
|
|
// string dataDir = @"..\..\..\..\..\Data\";
|
|
|
|
var allmds = new Dictionary<string, string>();
|
|
var allanchors = new Dictionary<string, IEnumerable<string>>();
|
|
var alllinks = new Dictionary<string, IEnumerable<Tuple<string, string>>>();
|
|
var allnames = new Dictionary<string, IEnumerable<string>>();
|
|
var resnames = Helpers.GetResourceNames();
|
|
foreach (var resname in resnames)
|
|
{
|
|
if (resname.EndsWith(".md"))
|
|
{
|
|
var name = resname.Substring(15, resname.Length - 18);
|
|
var md = await Helpers.GetResourceStringAsync(resname);
|
|
allmds.Add(name, md);
|
|
var anchors = GetMarkdownAnchors(md).ToList();
|
|
allanchors.Add(name, anchors);
|
|
var links = GetMarkdownLinks(md).ToList();
|
|
alllinks.Add(name, links);
|
|
var names = GetMarkdownAnchorNames(md).ToList();
|
|
allnames.Add(name, names);
|
|
}
|
|
}
|
|
foreach (var resname in resnames)
|
|
{
|
|
if (resname.EndsWith(".md"))
|
|
{
|
|
var name = resname.Substring(15, resname.Length - 18);
|
|
var md = await Helpers.GetResourceStringAsync(resname);
|
|
var unlinkedrefs = GetMarkdownUnlinkedRefs(md).ToList();
|
|
if (unlinkedrefs.Count > 0)
|
|
{
|
|
Console.WriteLine($"{name} :");
|
|
Console.WriteLine();
|
|
foreach (var unlinkedref in unlinkedrefs.Distinct().OrderBy(i => i))
|
|
{
|
|
//var file = "";
|
|
var files = new Dictionary<string, string>();
|
|
foreach(var aalinks in alllinks)
|
|
{
|
|
var found = aalinks.Value.FirstOrDefault(t => t.Item2 == Helpers.IdFromName(unlinkedref));
|
|
if(found != null)
|
|
{
|
|
files[found.Item1] = $"{found.Item1}.md";
|
|
//file = $"{found.Item1}.md";
|
|
//Console.WriteLine($"[{unlinkedref}]: {file}#{Helpers.IdFromName(unlinkedref)}");
|
|
}
|
|
}
|
|
foreach(var aanchors in allanchors)
|
|
{
|
|
if(aanchors.Value.Contains(Helpers.IdFromName(unlinkedref)))
|
|
{
|
|
files[aanchors.Key] = $"{aanchors.Key}.md";
|
|
//file = $"{aanchors.Key}.md";
|
|
//Console.WriteLine($"[{unlinkedref}]: {file}#{Helpers.IdFromName(unlinkedref)}");
|
|
//break;
|
|
}
|
|
}
|
|
if(files.Count == 0)
|
|
{
|
|
files[""] = "";
|
|
}
|
|
foreach (var file in files)
|
|
{
|
|
Console.WriteLine($"[{unlinkedref}]: {file.Value}#{Helpers.IdFromName(unlinkedref)}");
|
|
}
|
|
}
|
|
Console.WriteLine();
|
|
Console.WriteLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var links in alllinks)
|
|
{
|
|
foreach (var link in links.Value)
|
|
{
|
|
var file = link.Item1;
|
|
var anchor = link.Item2;
|
|
if (allanchors.ContainsKey(file))
|
|
{
|
|
if (!allanchors[file].Contains(anchor))
|
|
{
|
|
Console.WriteLine($"{links.Key} => {file} {anchor}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//foreach (var names in allnames)
|
|
//{
|
|
// foreach (var name in names.Value)
|
|
// {
|
|
// foreach(var mdkv in allmds)
|
|
// {
|
|
// FindName(mdkv.Value, name);
|
|
// }
|
|
// }
|
|
//}
|
|
}
|
|
|
|
public static void FindName(string md, string name)
|
|
{
|
|
var index = md.IndexOf(name);
|
|
while (index >= 0)
|
|
{
|
|
if ((md.Substring(index - 1, 1) != "[" ||
|
|
md.Substring(index + name.Length, 1) != "]") &&
|
|
md.Substring(index - 1, 1) != "#" &&
|
|
md.Substring(index - 2, 2) != "# ")
|
|
{
|
|
Console.WriteLine(name);
|
|
Console.WriteLine(md.Substring(index - 10, name.Length + 20).Replace("\n", "\\n"));
|
|
Console.WriteLine();
|
|
}
|
|
index = md.IndexOf(name, index + 1);
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<Tuple<string, string>> GetMarkdownLinks(string md)
|
|
{
|
|
var regex = new Regex("[ \\(](?<file>[a-z_]*?)\\.md#(?<anchor>.*?)[\\n\\)]");
|
|
var matches = regex.Matches(md);
|
|
foreach (Match match in matches)
|
|
{
|
|
var file = match.Groups["file"].Value;
|
|
var anchor = match.Groups["anchor"].Value;
|
|
yield return new Tuple<string, string>(file, anchor);
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<string> GetMarkdownUnlinkedRefs(string md)
|
|
{
|
|
var regex = new Regex("\\[(?<ref>.+?)\\]", RegexOptions.IgnoreCase);
|
|
var matches = regex.Matches(md);
|
|
md = md.ToLower();
|
|
foreach (Match match in matches)
|
|
{
|
|
var rref = match.Groups["ref"].Value;
|
|
var lref = rref.ToLower();
|
|
if (!md.Contains($"[{lref}]:") &&
|
|
!md.Contains($"[{lref}](") &&
|
|
!lref.Contains("]["))
|
|
{
|
|
yield return rref;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<string> GetMarkdownAnchors(string md)
|
|
{
|
|
foreach (var name in GetMarkdownAnchorNames(md))
|
|
{
|
|
yield return Helpers.IdFromName(name);
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<string> GetMarkdownAnchorNames(string md)
|
|
{
|
|
var regex = new Regex($"\\n##* (?<name>.*?)\\s*?\\n");
|
|
var matches = regex.Matches(md);
|
|
foreach (Match match in matches)
|
|
{
|
|
var name = match.Groups["name"].Value;
|
|
yield return name;
|
|
}
|
|
}
|
|
|
|
public static string Capitalize(string text)
|
|
{
|
|
return string.Concat(text.Take(1)).ToUpper() + string.Concat(text.Skip(1)).ToString().ToLower();
|
|
}
|
|
|
|
public static string RemoveDiacritics(string text)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
return text;
|
|
|
|
text = text.Normalize(NormalizationForm.FormD);
|
|
var chars = text.Where(c => CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark).ToArray();
|
|
return new string(chars).Normalize(NormalizationForm.FormC);
|
|
}
|
|
|
|
static string IdFromName(string name)
|
|
{
|
|
return RemoveDiacritics(name.ToLower().Replace(" ", "-"));
|
|
}
|
|
|
|
private static T LoadJSon<T>(string filename) where T : class
|
|
{
|
|
var serializer = new DataContractJsonSerializer(typeof(T));
|
|
using (var stream = new FileStream(filename, FileMode.Open))
|
|
{
|
|
return serializer.ReadObject(stream) as T;
|
|
}
|
|
}
|
|
|
|
private static void SaveJSon<T>(string filename, T objT) where T : class
|
|
{
|
|
var settings = new DataContractJsonSerializerSettings { UseSimpleDictionaryFormat = true };
|
|
var serializer = new DataContractJsonSerializer(typeof(T));
|
|
using (var stream = new FileStream(filename, FileMode.Create))
|
|
{
|
|
using (var writer = JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, true, true, " "))
|
|
{
|
|
serializer.WriteObject(writer, objT);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static async Task SaveStringAsync(string filename, string text)
|
|
{
|
|
using (var sw = new StreamWriter(path: filename, append: false, encoding: Encoding.UTF8))
|
|
{
|
|
await sw.WriteAsync(text);
|
|
}
|
|
}
|
|
|
|
private static async Task<string> LoadStringAsync(string filename)
|
|
{
|
|
using (var sr = new StreamReader(filename, Encoding.UTF8))
|
|
{
|
|
return await sr.ReadToEndAsync();
|
|
}
|
|
}
|
|
|
|
private static async Task<IEnumerable<string>> LoadList(string filename)
|
|
{
|
|
using (var stream = new StreamReader(filename))
|
|
{
|
|
var lines = new List<string>();
|
|
var line = await stream.ReadLineAsync();
|
|
while (line != null)
|
|
{
|
|
if (!string.IsNullOrEmpty(line))
|
|
{
|
|
lines.Add(line);
|
|
}
|
|
line = await stream.ReadLineAsync();
|
|
}
|
|
return lines;
|
|
}
|
|
}
|
|
}
|
|
}
|