private ToolContext CreateTool(TableOfContentsEntry toc, string ns, TypeResolver typeResolver)
{
var referenceDepth = CalculateReferenceDepth(toc);
var references = toc.IncludedReferences(referenceDepth, _settings.MinSubTasksForCategory);
var globalParameters = new Parameter[0];
var includedItems = new List <Item>();
foreach (var definition in _definitions)
{
foreach (var definitionItem in definition.Items)
{
if (definitionItem.Uid != toc.Uid && !references.Contains(definitionItem.Uid))
{
continue;
}
includedItems.Add(definitionItem);
if (globalParameters.Length == 0)
{
globalParameters = definition.GlobalParameters;
}
}
}
return(new ToolContext(ns, DefinitionParser.Parse(toc, ns, includedItems, globalParameters, typeResolver)));
}
public void AddEntry(string title, MarkdownHeading target, bool subtitle = false)
{
var entry = new TableOfContentsEntry(title, target, subtitle);
if (subtitle)
{
lastMainTitle.Margin = new MarginPadding(0);
if (lastSubTitle != null)
{
lastSubTitle.Margin = new MarginPadding(0);
}
content.Add(lastSubTitle = entry.With(d => d.Margin = new MarginPadding {
Bottom = 10
}));
return;
}
lastSubTitle = null;
content.Add(lastMainTitle = entry.With(d => d.Margin = new MarginPadding {
Bottom = 5
}));
}
private IEnumerable <ToolContext> CreateTools(
TableOfContentsEntry toc,
IEnumerable <TableOfContentsEntry> categories,
TypeResolver typeResolver = null)
{
var tools = new List <ToolContext>();
var tableOfContentsEntries = categories as TableOfContentsEntry[] ?? categories.ToArray();
var ns = GetNamespace(toc);
typeResolver = typeResolver?.Clone(ns) ?? new TypeResolver(ns);
if (tableOfContentsEntries.Contains(toc))
{
tools.Add(CreateTool(toc, ns, typeResolver));
}
foreach (var tableOfContentsEntry in toc.Items)
{
tools.AddRange(CreateTools(tableOfContentsEntry,
tableOfContentsEntries,
typeResolver));
}
return(tools);
}
private string GetNamespace(TableOfContentsEntry toc)
{
if (_settings.SingleNamespace)
{
return(_settings.BaseNamespace);
}
var ns = _settings.BaseNamespace;
var baseToc = toc;
while (baseToc.Depth < _settings.MinDepthForCategory)
{
if (baseToc.Parent == null)
{
break;
}
baseToc = baseToc.Parent;
}
var name = baseToc.DisplayName ?? baseToc.Uid.NotNull().Replace("_", " ");
var segments = name.Length > 2 ? name.Substring(startIndex: 3).Split(separator: ' ') : new string[0];
var current = string.Empty;
for (var i = 0; i < segments.Length && i < _settings.MaxDepth; i++)
{
current += segments[i].ToPascalCase(separator: '-');
if (i % _settings.MinDepthForCategory == 0)
{
ns += '.' + current;
current = string.Empty;
}
}
return(ns);
}
private DefinitionParser(TableOfContentsEntry toc, string ns, List <Item> items, Parameter[] parameters, TypeResolver typeResolver)
{
_toc = toc;
_namespace = ns;
_items = items;
_parameters = parameters;
_typeResolver = typeResolver;
_tool = CreateTool();
}
private SpecificationGenerator(
SpecificationGeneratorSettings settings,
IReadOnlyCollection <Definition> definitions,
TableOfContentsEntry referenceToc)
{
_settings = settings;
_definitions = definitions;
_toc = referenceToc;
}
private int CalculateReferenceDepth(TableOfContentsEntry toc)
{
if (toc.Parent == null /*|| toc.Depth >= _settings.MinDepthForCategory*/)
{
return(0);
}
var referenceDepth = toc.Depth - _settings.MaxDepth;
referenceDepth = referenceDepth < 0 ? 0 : referenceDepth;
referenceDepth = Math.Max(referenceDepth, _settings.MinDepthForCategory - 1);
return(referenceDepth);
}
private static void PoupuateTocInformation(TableOfContentsEntry toc, [CanBeNull] TableOfContentsEntry parent, out int depth, out int commands)
{
commands = toc.HasItems && toc.Items.All(x => x.HasItems) ? 0 : 1;
depth = 0;
foreach (var tableOfContentsEntry in toc.Items)
{
PoupuateTocInformation(tableOfContentsEntry, toc, out var depthResult, out var commandResult);
if (depthResult > depth)
{
depth = depthResult;
}
commands += commandResult;
}
if (toc.HasItems)
{
depth++;
}
toc.Parent = parent;
toc.TotalCommandsInTable = commands;
toc.Depth = depth;
}
public static Tool Parse(TableOfContentsEntry toc, string ns, List <Item> items, Parameter[] parameters, TypeResolver typeResolver)
{
return(new DefinitionParser(toc, ns, items, parameters, typeResolver).Parse());
}
