amis92 · November 2, 2019 13:54 · amis92 · Nov 2, 2019
diff --git a/childid-check.csx b/childid-check.csx
 #!/usr/bin/env dotnet-script

 // Author: Amadeusz Sadowski
 #r "nuget: morelinq, 3.2.0"
 #r "nuget: WarHub.ArmouryModel.Workspaces.BattleScribe, [0.7.0-beta.3]"
 using System.Collections.Immutable;
 using System.Text.RegularExpressions;
 using MoreLinq;
 using WarHub.ArmouryModel.Source;
 using WarHub.ArmouryModel.Source.BattleScribe;
 using WarHub.ArmouryModel.Workspaces.BattleScribe;

 public class Context
 {
    public ImmutableDictionary<string, SourceNode> Index { get; }

    public CatalogueBaseNode CatalogueBase { get; }

    public XmlWorkspace Workspace { get; }

    private Context(ImmutableDictionary<string, SourceNode> index, CatalogueBaseNode catalogueBase, XmlWorkspace workspace)
    {
        Index = index;
        CatalogueBase = catalogueBase;
        Workspace = workspace;
    }

    public static Context Create(XmlDocument document) =>
        Create((CatalogueBaseNode)document.GetRoot(), document.Workspace);

    public static Context Create(CatalogueBaseNode catalogueBase, XmlWorkspace workspace)
    {
        var nonIndexableKinds =
            ImmutableHashSet.Create(
                SourceKind.CatalogueLinkList,
                SourceKind.CategoryLinkList,
                SourceKind.ConstraintList,
                SourceKind.CostTypeList,
                SourceKind.ProfileTypeList,
                SourceKind.PublicationList);
        var workspaceIndex =
            workspace.GetDocuments(SourceKind.Catalogue, SourceKind.Gamesystem)
            .Select(x => (CatalogueBaseNode)x.GetRoot())
            .ToImmutableDictionary(x => x.Id);
        var index =
            new [] { catalogueBase }
            .Concat(catalogueBase switch
            {
                CatalogueNode c => GetImports(c).Append(workspaceIndex[c.GamesystemId]),
                _ => new CatalogueBaseNode[0]
            })
            .Distinct()
            .SelectMany(x => x.DescendantsAndSelf(current => !nonIndexableKinds.Contains(current.Kind)))
            .OfType<IIdentifiableNode>()
            .Concat(workspaceIndex.Values)
            .DistinctBy(x => x.Id)
            .ToImmutableDictionary(x => x.Id, x => (SourceNode)x);
        return new Context(index, catalogueBase, workspace);

        IEnumerable<CatalogueNode> GetImports(CatalogueNode cat)
        {
            return
                cat.CatalogueLinks
                .Select(x => (CatalogueNode)workspaceIndex[x.TargetId])
                .SelectMany(x => GetImports(x).Append(x));
        }
    }
 }

 public class ConditionChildTargetVisitor : SourceWalker
 {
    public delegate void Process(ConditionNode selector, EntryLinkNode link);
    private readonly Process processAffected;
    private readonly Action<SourceNode, string> processError;
    private readonly Context context;
    private readonly ImmutableHashSet<string> wellKnownIds =
        ImmutableHashSet.Create(
            "any",
            "unit",
            "model",
            "upgrade");

    public ConditionChildTargetVisitor(
        Context context,
        Process processAffected,
        Action<SourceNode, string> processError = null)
    {
        this.processAffected = processAffected;
        this.processError = processError;
        this.context = context;
    }

    public override void VisitCondition(ConditionNode node)
    {
        if (wellKnownIds.Contains(node.ChildId))
        {
            return;
        }
        if (!context.Index.TryGetValue(node.ChildId, out var target))
        {
            processError(node, "ChildId target not found");
        }
        if (target is EntryLinkNode link)
        {
            processAffected(node, link);
        }
    }
 }

 public class InstanceOfConditionRewriter : SourceRewriter
 {
    public delegate ConditionNode Rewrite(ConditionNode condition, EntryLinkNode link);
    private readonly Context context;
    private readonly Rewrite rewrite;
    private readonly ImmutableHashSet<string> wellKnownIds =
        ImmutableHashSet.Create(
            "any",
            "unit",
            "model",
            "upgrade");

    public InstanceOfConditionRewriter(Context context, Rewrite rewrite)
    {
        this.context = context;
        this.rewrite = rewrite;
    }

    public override SourceNode VisitCondition(ConditionNode node)
    {
        if ((node.Type == ConditionKind.InstanceOf || node.Type == ConditionKind.NotInstanceOf)
            && !wellKnownIds.Contains(node.ChildId)
            && context.Index[node.ChildId] is EntryLinkNode link)
        {
            return rewrite(node, link);
        }
        return node;
    }
 }

 string GetAncestryString(SourceNode node)
 {
    var ancestry =
        (from anc in node.AncestorsAndSelf().Reverse()
        select anc switch
        {
            INameableNode nameable => nameable.Name,
            IIdentifiableNode ident => $"{anc.Kind} {ident.Id}",
            { Parent: {IsList: true} } => $"{anc.Kind}[{anc.IndexInParent + 1}]",
            { Parent: { } } => $"{anc.GetChildInfoFromParent().Name}",
            _ => anc.Kind.ToString()
        });
    return string.Join(" -> ", ancestry);
 }

 var anchorRegex = new Regex(@"[^a-z0-9\-]+");
 string GetAnchorString(string source)
 {
    var stg1 = source.ToLowerInvariant().Replace(" ", "-");
    return anchorRegex.Replace(stg1, "");
 }


 void FindIssues(XmlDocument file)
 {
    var context = Context.Create(file);
    var visitor = new ConditionChildTargetVisitor(context, (condition, link) =>
    {
        if (condition.Type == ConditionKind.InstanceOf || condition.Type == ConditionKind.NotInstanceOf)
        {
            i++;
            Write("+ ");
            WriteLine(GetAncestryString(condition));
        }
    }, (node, error) =>
    {
        WriteLine($"> **{error}** {GetAncestryString(node)}");
    });
    context.CatalogueBase.Accept(visitor);
 }
 void FixIssues(XmlDocument file)
 {
    var context = Context.Create(file);
    var visitor = new InstanceOfConditionRewriter(context, (condition, link) =>
    {
        i++;
        Write("+ ");
        WriteLine(GetAncestryString(condition));
        if (!context.Index.TryGetValue(link.TargetId, out var target))
        {
            WriteLine($"  - failed to resolve child's target (link ID: {link.TargetId})");
            return condition;
        }
        if (!(target is SelectionEntryBaseNode targetEntry))
        {
            WriteLine($"  - child's target is not a SelectionEntry(Group) (link ID: {link.TargetId})");
            return condition;
        }
        WriteLine($"  - replaced `childId` of {condition.ChildId} (link) with {link.TargetId} (_{targetEntry.Name}_)");
        return condition.WithChildId(link.TargetId);
    });
    var rewritten = (CatalogueBaseNode)context.CatalogueBase.Accept(visitor);
    using var fileStream = File.OpenWrite(file.Filepath);
    rewritten.Serialize(fileStream);
 }

 Action<XmlDocument> operation = FindIssues;
 if (Args.Any(x => x == "--fix"))
 {
    operation = FixIssues;
 }
 var results = new Dictionary<string, int>();
 var i = 0;
 var ws = XmlWorkspace.CreateFromDirectory(".");
 var files = Args.Where(x => !x.StartsWith("-")) is var paths && paths.Any() ?
    (from path in paths
    let expPath = Path.GetFullPath(path)
    select ws.Documents.Single(df => string.Equals(expPath, df.Filepath, StringComparison.OrdinalIgnoreCase)))
    : ws.Documents.Where(df => df.Kind == XmlDocumentKind.Catalogue || df.Kind == XmlDocumentKind.Gamesystem);
 foreach (var file in files)
 {
    WriteLine("# " + file.Name);
    WriteLine($"[{file.Name}]:#{GetAnchorString(file.Name)}");
    i = 0;
    operation(file);
    WriteLine();
    WriteLine($"_Count: {i}_");
    WriteLine();
    WriteLine();
    results[file.Name] = i;
 }

 void PrintSummary()
 {
    var tableRows = new[]
        {
            ("File", "Count"),
            ("-", "-:"),
        }
        .Concat(
            results
            .Where(x => x.Value > 0)
            .Select(x => ($"[{x.Key}]", x.Value.ToString())))
        .Append(("**Total**", results.Values.Sum().ToString()))
        .ToList();

    var padding = new[]
        {
            tableRows.Max(x => x.Item1.Length),
            tableRows.Max(x => x.Item2.Length),
        };

    WriteLine();
    WriteLine("---");
    WriteLine();
    WriteLine("# Summary");
    WriteLine();
    foreach (var (c1, c2) in tableRows)
    {
        WriteLine($"| {c1.PadRight(padding[0])} | {c2.ToString().PadLeft(padding[1])} |");
    }
 }
 PrintSummary();
diff --git a/output-40k-fixer.md b/output-40k-fixer.md
	#!/usr/bin/env dotnet-script

	// Author: Amadeusz Sadowski
	#r "nuget: morelinq, 3.2.0"
	#r "nuget: WarHub.ArmouryModel.Workspaces.BattleScribe, [0.7.0-beta.3]"
	using System.Collections.Immutable;
	using System.Text.RegularExpressions;
	using MoreLinq;
	using WarHub.ArmouryModel.Source;
	using WarHub.ArmouryModel.Source.BattleScribe;
	using WarHub.ArmouryModel.Workspaces.BattleScribe;

	public class Context
	{
	public ImmutableDictionary<string, SourceNode> Index { get; }

	public CatalogueBaseNode CatalogueBase { get; }

	public XmlWorkspace Workspace { get; }

	private Context(ImmutableDictionary<string, SourceNode> index, CatalogueBaseNode catalogueBase, XmlWorkspace workspace)
	{
	Index = index;
	CatalogueBase = catalogueBase;
	Workspace = workspace;
	}

	public static Context Create(XmlDocument document) =>
	Create((CatalogueBaseNode)document.GetRoot(), document.Workspace);

	public static Context Create(CatalogueBaseNode catalogueBase, XmlWorkspace workspace)
	{
	var nonIndexableKinds =
	ImmutableHashSet.Create(
	SourceKind.CatalogueLinkList,
	SourceKind.CategoryLinkList,
	SourceKind.ConstraintList,
	SourceKind.CostTypeList,
	SourceKind.ProfileTypeList,
	SourceKind.PublicationList);
	var workspaceIndex =
	workspace.GetDocuments(SourceKind.Catalogue, SourceKind.Gamesystem)
	.Select(x => (CatalogueBaseNode)x.GetRoot())
	.ToImmutableDictionary(x => x.Id);
	var index =
	new [] { catalogueBase }
	.Concat(catalogueBase switch
	{
	CatalogueNode c => GetImports(c).Append(workspaceIndex[c.GamesystemId]),
	_ => new CatalogueBaseNode[0]
	})
	.Distinct()
	.SelectMany(x => x.DescendantsAndSelf(current => !nonIndexableKinds.Contains(current.Kind)))
	.OfType<IIdentifiableNode>()
	.Concat(workspaceIndex.Values)
	.DistinctBy(x => x.Id)
	.ToImmutableDictionary(x => x.Id, x => (SourceNode)x);
	return new Context(index, catalogueBase, workspace);

	IEnumerable<CatalogueNode> GetImports(CatalogueNode cat)
	{
	return
	cat.CatalogueLinks
	.Select(x => (CatalogueNode)workspaceIndex[x.TargetId])
	.SelectMany(x => GetImports(x).Append(x));
	}
	}
	}

	public class ConditionChildTargetVisitor : SourceWalker
	{
	public delegate void Process(ConditionNode selector, EntryLinkNode link);
	private readonly Process processAffected;
	private readonly Action<SourceNode, string> processError;
	private readonly Context context;
	private readonly ImmutableHashSet<string> wellKnownIds =
	ImmutableHashSet.Create(
	"any",
	"unit",
	"model",
	"upgrade");

	public ConditionChildTargetVisitor(
	Context context,
	Process processAffected,
	Action<SourceNode, string> processError = null)
	{
	this.processAffected = processAffected;
	this.processError = processError;
	this.context = context;
	}

	public override void VisitCondition(ConditionNode node)
	{
	if (wellKnownIds.Contains(node.ChildId))
	{
	return;
	}
	if (!context.Index.TryGetValue(node.ChildId, out var target))
	{
	processError(node, "ChildId target not found");
	}
	if (target is EntryLinkNode link)
	{
	processAffected(node, link);
	}
	}
	}

	public class InstanceOfConditionRewriter : SourceRewriter
	{
	public delegate ConditionNode Rewrite(ConditionNode condition, EntryLinkNode link);
	private readonly Context context;
	private readonly Rewrite rewrite;
	private readonly ImmutableHashSet<string> wellKnownIds =
	ImmutableHashSet.Create(
	"any",
	"unit",
	"model",
	"upgrade");

	public InstanceOfConditionRewriter(Context context, Rewrite rewrite)
	{
	this.context = context;
	this.rewrite = rewrite;
	}

	public override SourceNode VisitCondition(ConditionNode node)
	{
	if ((node.Type == ConditionKind.InstanceOf \|\| node.Type == ConditionKind.NotInstanceOf)
	&& !wellKnownIds.Contains(node.ChildId)
	&& context.Index[node.ChildId] is EntryLinkNode link)
	{
	return rewrite(node, link);
	}
	return node;
	}
	}

	string GetAncestryString(SourceNode node)
	{
	var ancestry =
	(from anc in node.AncestorsAndSelf().Reverse()
	select anc switch
	{
	INameableNode nameable => nameable.Name,
	IIdentifiableNode ident => $"{anc.Kind} {ident.Id}",
	{ Parent: {IsList: true} } => $"{anc.Kind}[{anc.IndexInParent + 1}]",
	{ Parent: { } } => $"{anc.GetChildInfoFromParent().Name}",
	_ => anc.Kind.ToString()
	});
	return string.Join(" -> ", ancestry);
	}

	var anchorRegex = new Regex(@"[^a-z0-9\-]+");
	string GetAnchorString(string source)
	{
	var stg1 = source.ToLowerInvariant().Replace(" ", "-");
	return anchorRegex.Replace(stg1, "");
	}


	void FindIssues(XmlDocument file)
	{
	var context = Context.Create(file);
	var visitor = new ConditionChildTargetVisitor(context, (condition, link) =>
	{
	if (condition.Type == ConditionKind.InstanceOf \|\| condition.Type == ConditionKind.NotInstanceOf)
	{
	i++;
	Write("+ ");
	WriteLine(GetAncestryString(condition));
	}
	}, (node, error) =>
	{
	WriteLine($"> {error} {GetAncestryString(node)}");
	});
	context.CatalogueBase.Accept(visitor);
	}
	void FixIssues(XmlDocument file)
	{
	var context = Context.Create(file);
	var visitor = new InstanceOfConditionRewriter(context, (condition, link) =>
	{
	i++;
	Write("+ ");
	WriteLine(GetAncestryString(condition));
	if (!context.Index.TryGetValue(link.TargetId, out var target))
	{
	WriteLine($" - failed to resolve child's target (link ID: {link.TargetId})");
	return condition;
	}
	if (!(target is SelectionEntryBaseNode targetEntry))
	{
	WriteLine($" - child's target is not a SelectionEntry(Group) (link ID: {link.TargetId})");
	return condition;
	}
	WriteLine($" - replaced `childId` of {condition.ChildId} (link) with {link.TargetId} (_{targetEntry.Name}_)");
	return condition.WithChildId(link.TargetId);
	});
	var rewritten = (CatalogueBaseNode)context.CatalogueBase.Accept(visitor);
	using var fileStream = File.OpenWrite(file.Filepath);
	rewritten.Serialize(fileStream);
	}

	Action<XmlDocument> operation = FindIssues;
	if (Args.Any(x => x == "--fix"))
	{
	operation = FixIssues;
	}
	var results = new Dictionary<string, int>();
	var i = 0;
	var ws = XmlWorkspace.CreateFromDirectory(".");
	var files = Args.Where(x => !x.StartsWith("-")) is var paths && paths.Any() ?
	(from path in paths
	let expPath = Path.GetFullPath(path)
	select ws.Documents.Single(df => string.Equals(expPath, df.Filepath, StringComparison.OrdinalIgnoreCase)))
	: ws.Documents.Where(df => df.Kind == XmlDocumentKind.Catalogue \|\| df.Kind == XmlDocumentKind.Gamesystem);
	foreach (var file in files)
	{
	WriteLine("# " + file.Name);
	WriteLine($"[{file.Name}]:#{GetAnchorString(file.Name)}");
	i = 0;
	operation(file);
	WriteLine();
	WriteLine($"_Count: {i}_");
	WriteLine();
	WriteLine();
	results[file.Name] = i;
	}

	void PrintSummary()
	{
	var tableRows = new[]
	{
	("File", "Count"),
	("-", "-:"),
	}
	.Concat(
	results
	.Where(x => x.Value > 0)
	.Select(x => ($"[{x.Key}]", x.Value.ToString())))
	.Append(("Total", results.Values.Sum().ToString()))
	.ToList();

	var padding = new[]
	{
	tableRows.Max(x => x.Item1.Length),
	tableRows.Max(x => x.Item2.Length),
	};

	WriteLine();
	WriteLine("---");
	WriteLine();
	WriteLine("# Summary");
	WriteLine();
	foreach (var (c1, c2) in tableRows)
	{
	WriteLine($"\| {c1.PadRight(padding[0])} \| {c2.ToString().PadLeft(padding[1])} \|");
	}
	}
	PrintSummary();
File	Count
Aeldari - Craftworlds	1
Aeldari - Drukhari	2
Imperium - Dark Angels	7
Imperium - Deathwatch	2
Imperium - Grey Knights	12
Imperium - Questor Imperialis	1
T'au Empire	1
Total	26