/// <summary>
/// Copies to a given node.
/// </summary>
/// <param name="targetNode">The node wherer to copy.</param>
/// <param name="name">The node name.</param>
public void CopyTo(CSharpSyntaxMatchingNode targetNode, string name)
{
// Data validation
Ensure.That(() => name).IsNotNullOrWhiteSpace();
Ensure.That(() => targetNode).IsNotNull();
// Ensure and retrieve a node the the copy
CSharpSyntaxMatchingNode newNode = targetNode.EnsureNode(name);
// Add syntax node to the created node
if (null != this.matchingSyntaxNodes)
{
// Lazy create the syntax nodes
if (null == newNode.matchingSyntaxNodes)
{
newNode.matchingSyntaxNodes = new List<SyntaxNode>();
}
// Merge syntax nodes
int[] indexes = newNode.matchingSyntaxNodes.Select(x => x.Span.Start).ToArray();
newNode.matchingSyntaxNodes.AddRange(this.matchingSyntaxNodes.Where(x => !indexes.Contains(x.Span.Start)));
}
// Recurse for applying copy to the children
if (null != this.children && this.children.Count > 0)
{
string[] childrenName = this.children.Keys.ToArray();
foreach (string childName in childrenName)
{
this.children[childName].CopyTo(newNode, childName);
}
}
}
/// <summary>
/// Extracts a snippet from a given rule pattern.
/// </summary>
/// <param name="memberPattern">The mem.</param>
/// <returns>The extracted snippet.</returns>
public override Model.Snippet Extract(string filePath, string memberPattern)
{
// Return the entire code if no member is specified
if (string.IsNullOrWhiteSpace(memberPattern))
{
return base.Extract(filePath, memberPattern);
}
// Parse the matching rule from the pattern
CSharpMatchingRule rule = CSharpMatchingRule.Parse(memberPattern);
// Load the trie for pattern matching
if (null == this.syntaxTrie)
{
// Load file content
string sourceCode = base.LoadFile(filePath);
// Build a syntax tree from the source code
SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceCode);
SyntaxNode root = tree.GetRoot();
// Visit the syntax tree for generating a Trie for pattern matching
CSharpSyntaxWalkerMatchingBuilder syntaxMatchingBuilder = new CSharpSyntaxWalkerMatchingBuilder();
syntaxMatchingBuilder.Visit(root);
// Retrieve the Trie root
this.syntaxTrie = syntaxMatchingBuilder.Root;
}
// Match the rule from the syntax matching Trie
CSharpSyntaxMatchingNode matchingTrie = syntaxTrie.Match(rule.MatchingChunks);
if (null == matchingTrie)
{
throw new SnippetExtractionException("Cannot find member", string.Format("{0} {1}", filePath, memberPattern));
}
// Build a snippet for extracted syntax nodes
return this.BuildSnippet(matchingTrie.MatchingSyntaxNodes, rule.ExtractionMode);
}