/// <summary>
/// Generate treescheme json for a given type.
/// </summary>
/// <param name="rootAliasTypeName">Fullname of the type to use as the root of the tree</param>
/// <param name="fieldSource">Enum to indicator how to find fields on types</param>
/// <param name="typeIgnorePattern">Optional regex pattern to ignore types</param>
/// <param name="nodeCommentProvider">Optional provider of node-comments</param>
/// <param name="logger">Optional logger for diagnostic output</param>
/// <returns>Json string representing the scheme</returns>
public static string GenerateScheme(
string rootAliasTypeName,
FieldSource fieldSource,
Regex typeIgnorePattern = null,
INodeCommentProvider nodeCommentProvider = null,
Core.ILogger logger = null)
{
try
{
// Gather all the types.
var typeCollection = TypeCollection.Create(AppDomain.CurrentDomain.GetAssemblies(), logger);
// Create mapping context.
var context = Context.Create(
typeCollection,
fieldSource,
typeIgnorePattern,
nodeCommentProvider,
logger);
// Map the tree.
var tree = TreeMapper.MapTree(context, rootAliasTypeName);
// Serialize the scheme.
return(JsonSerializer.ToJson(tree, JsonSerializer.Mode.Pretty));
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate scheme: {e.Message.ToDistinctLines()}");
return(null);
}
}
public void Should_be_able_to_determine_siblings_from_given_node()
{
var inputText = "(def my-name \"Me\")";
var rootNode = inputText.CreateAstNodes();
var nodeMapper = new TreeMapper <AstNode>();
var map = nodeMapper.CreateMap(rootNode);
var defNode = rootNode.Descendants().OfType <SymbolNode>().First(s => s.Symbol == "def");
map.GetSiblingsFor(defNode).Count().ShouldBe(2);
}
public void Should_be_able_to_determine_parent_from_given_node()
{
var inputText = "(def my-name \"Me\")";
var rootNode = inputText.CreateAstNodes();
var nodeMapper = new TreeMapper <AstNode>();
var map = nodeMapper.CreateMap(rootNode);
var children = rootNode.Children;
foreach (var child in children)
{
map.GetParentFor(child).ShouldBe(rootNode);
}
}
public void Should_be_able_to_determine_parent_from_nested_node()
{
var inputText = "(keyword1 keyword2 (keyword3 keyword4 (keyword5 keyword6)))";
var rootNode = inputText.CreateAstNodes();
var nodeMapper = new TreeMapper <AstNode>();
var map = nodeMapper.CreateMap(rootNode);
var topNode = (ListNode)rootNode.Children.First();
var children = topNode.Children;
foreach (var child in children)
{
map.GetParentFor(child).ShouldBe(topNode);
}
}
/*
* This function attempts to parse the tree using the TreeMapper class
* and generates the list of nodes. Then forces a repaint of the window
*/
void parseTree()
{
//If we have a tree
if (CurrentTree && CurrentTree.StartNode)
{
if (CurrentTree.integrityCheck())
{
CurrentTree.deepDepthCheck(CurrentTree.StartNode);
TreeMapper.MapTree(CurrentTree);
nodes = CurrentTree.gameObject.GetComponents <TreeNode>().ToList();
Repaint();
}
else
{
Debug.LogFormat("The Integrity of the Tree has failed!\nDid you remove a node from the Inspector?\nRepairing...");
}
}
}
public void Should_be_able_to_determine_root_ancestry_from_child_node()
{
var inputText = "(parent (child))";
var rootNode = inputText.CreateAstNodes();
var nodeMapper = new TreeMapper <AstNode>();
var map = nodeMapper.CreateMap(rootNode);
var descendants = rootNode.Descendants().ToArray();
var childNode = descendants.OfType <SymbolNode>().First(node => node.Symbol == "child");
var ancestryChain = map.GetRootAncestryFor(childNode).ToArray();
ancestryChain[0].ShouldBe(childNode);
ancestryChain[1].ShouldBeOfType <ListNode>();
ancestryChain[2].ShouldBeOfType <ListNode>();
ancestryChain[3].ShouldBe(rootNode);
}
/// <summary>
/// Run the generator tool.
/// </summary>
/// <param name="assemblyFile">Assembly to generate the scheme for</param>
/// <param name="dependencyDirectories">Optional paths to look for dependencies</param>
/// <param name="rootType">Root type of the tree</param>
/// <param name="fieldSource">Source to find fields</param>
/// <param name="typeIgnorePattern">Optional regex pattern for ignoring types</param>
/// <param name="outputPath">Path where to generate the output scheme to</param>
/// <returns>Exit code</returns>
public int Run(
string assemblyFile,
IEnumerable <string> dependencyDirectories,
string rootType,
FieldSource fieldSource,
Regex typeIgnorePattern,
string outputPath)
{
if (assemblyFile == null)
{
throw new ArgumentNullException(nameof(assemblyFile));
}
if (dependencyDirectories == null)
{
throw new ArgumentNullException(nameof(dependencyDirectories));
}
if (rootType == null)
{
throw new ArgumentNullException(nameof(rootType));
}
// Load types from given assembly.
var typeCollection = TypeLoader.TryLoad(assemblyFile, dependencyDirectories, this.logger);
if (typeCollection == null)
{
return(1);
}
// Verify that root-type can be found in those types.
if (!typeCollection.TryGetType(rootType, out _))
{
this.logger.LogCritical($"Unable to find root-type: '{rootType}'");
return(1);
}
// Load doc-comment file for providing node comments.
XmlNodeCommentProvider nodeCommentProvider = null;
var xmlDocFilePath = Path.ChangeExtension(assemblyFile, "xml");
if (File.Exists(xmlDocFilePath))
{
this.logger.LogInformation($"Using doc-comment file: '{xmlDocFilePath}'");
using (var stream = new FileStream(xmlDocFilePath, FileMode.Open, FileAccess.Read))
{
if (!XmlNodeCommentProvider.TryParse(stream, out nodeCommentProvider))
{
this.logger?.LogWarning($"Failed to parse doc-comment file: '{xmlDocFilePath}'");
}
}
}
// Create context object containing all the settings for the mapping.
var context = Context.Create(
typeCollection,
fieldSource,
typeIgnorePattern,
nodeCommentProvider,
this.logger.IsEnabled(LogLevel.Debug) ? this.logger : null);
// Map the tree.
TreeDefinition tree = null;
try
{
tree = TreeMapper.MapTree(context, rootType);
this.logger.LogInformation(
$"Mapped tree (aliases: '{tree.Aliases.Length}', enums: '{tree.Enums.Length}', nodes: '{tree.Nodes.Length}')");
}
catch (Core.Mapping.Exceptions.MappingFailureException e)
{
this.logger.LogCritical($"Failed to map: '{e.InnerException.Message}'");
return(1);
}
// Save the result.
try
{
Directory.GetParent(outputPath).Create();
using (var stream = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
{
JsonSerializer.WriteJson(tree, JsonSerializer.Mode.Pretty, stream);
}
this.logger.LogInformation($"Written scheme to: '{outputPath}'");
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to save to '{outputPath}': {e.Message}");
return(1);
}
return(0);
}
