private IModelNode TransformVertexRecursive(IModelNode vertex, TransformRule[] transforms)
{
var newName = transforms.Aggregate(
vertex.DisplayName,
(name, rule) => GetTransform(rule.Pattern).Replace(name, rule.Name ?? string.Empty));
var type = vertex.Type;
var linesOfCode = vertex.LinesOfCode;
var maintainabilityIndex = vertex.MaintainabilityIndex;
var cyclomaticComplexity = vertex.CyclomaticComplexity;
var quality = vertex.Quality;
var children = vertex.Children.Select(x => TransformVertexRecursive(x, transforms));
return vertex is StaticModelNode
? new StaticModelNode(
newName,
type,
quality,
linesOfCode,
maintainabilityIndex,
cyclomaticComplexity,
children.ToList())
: new ModelNode(
newName,
type,
quality,
linesOfCode,
maintainabilityIndex,
cyclomaticComplexity,
children.ToList());
}
protected override void Initialize()
{
worklist = new Stack <InstructionNode>();
transformRules = new List <TransformRule>();
var symbolDictionary = new SymbolDictionary();
symbolDictionary.Add(Architecture);
symbolDictionary.Add(IRInstructionList.List);
foreach (var rule in Rules.List)
{
var matchTokens = Tokenizer.Parse(rule.Match, ParseType.Instructions);
var criteriaTokens = Tokenizer.Parse(rule.Criteria, ParseType.Expression);
var transformTokens = Tokenizer.Parse(rule.Transform, ParseType.Instructions);
var matchNodes = NodeParser.Parse(matchTokens, symbolDictionary);
var criteriaExpression = ExpressionParser.Parse(criteriaTokens);
var transformNodes = NodeParser.Parse(transformTokens, symbolDictionary);
var transformRule = new TransformRule(matchNodes, criteriaExpression, transformNodes);
transformRules.Add(transformRule);
}
}
public async Task WhenTransformingThenTransformsDisplayName()
{
var rule = new TransformRule("Test", "[xyz]");
var node = new ModelNode("x", "type", CodeQuality.Good, 3, 2, 1);
var transformed = await _transformer.Transform(new[] { node }, new[] { rule }, CancellationToken.None);
Assert.AreEqual("Test", transformed.First().DisplayName);
}
public async Task WhenTransformingThenAlsoTransformsChildren()
{
var rule = new TransformRule("Test", "[xyz]");
var node = new ModelNode("a", "type", CodeQuality.Good, 3, 2, 1, new List<IModelNode> { new ModelNode("x", "type", CodeQuality.Good, 6, 5, 4) });
var transformed = await _transformer.Transform(new[] { node }, new[] { rule }, CancellationToken.None);
Assert.Equal("Test", transformed.First().Children.First().DisplayName);
}
public async Task WhenTransformingThenAlsoTransformsChildren()
{
var rule = new TransformRule("Test", "[xyz]");
var node = new ModelNode("a", "type", CodeQuality.Good, 3, 2, 1, new List <IModelNode> {
new ModelNode("x", "type", CodeQuality.Good, 6, 5, 4)
});
var transformed = await _transformer.Transform(new[] { node }, new[] { rule }, CancellationToken.None);
Assert.Equal("Test", transformed.First().Children.First().DisplayName);
}
/// <summary>
/// Apply a specific transformation rule to a specific tile
/// </summary>
/// <param name="rule">The TRANFROM_RULE to be applied to this tile</param>
/// <param name="position">The position of the tile on the tilemap</param>
/// <param name="neighbors">the tile's neighborhood, the 3x3 area around the tile as a 1D array</param>
/// <returns></returns>
public TileBase ApplyRule(TransformRule rule, Vector3Int position, TileBase[] neighbors, BoundsInt bounds)
{
if (rule == TransformRule.WALL_FROM_BOUNDS)
{
var newTileType = rules[TransformRule.WALL_FROM_BOUNDS].Apply(position, bounds);
if (newTileType != null)
{
return(TilemapHelper.GetTileByType(newTileType));
}
}
if (rule == TransformRule.WALL_FROM_ADJACENTS)
{
var newTileType = rules[TransformRule.WALL_FROM_ADJACENTS].Apply(neighbors);
if (newTileType != null)
{
return(TilemapHelper.GetTileByType(newTileType));
}
}
if (rule == TransformRule.WALL_FOR_ROOM)
{
var newTileType = rules[TransformRule.WALL_FOR_ROOM].Apply(neighbors);
if (newTileType != null)
{
return(TilemapHelper.GetTileByType(newTileType));
}
}
if (rule == TransformRule.ROOM_FROM_ADJACENTS)
{
var newTileType = rules[TransformRule.ROOM_FROM_ADJACENTS].Apply(neighbors);
if (newTileType != null)
{
return(TilemapHelper.GetTileByType(newTileType));
}
}
if (rule == TransformRule.FLOOR_FROM_BOUNDS)
{
var newTileType = rules[TransformRule.FLOOR_FROM_BOUNDS].Apply(position, bounds);
if (newTileType != null)
{
return(TilemapHelper.GetTileByType(newTileType));
}
}
return(null);
}
