public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsCommentNode;
var destNode = CommentNodeFactory.CreateCommentNode(srcNode.Text);
return(new IRazorNode[] { destNode });
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = (IWebFormsHtmlTagNode)node;
if (srcNode.BlockType == CodeBlockNodeType.Complete)
{
return(new[]
{
textNodeFactory.CreateTextNode("<" + ConvertToRazor(srcNode.Content.TrimStart('<')), CodeBlockNodeType.Complete)
});
}
var convertedChildren = node.Children
.SelectMany(childNode => nodeConverterProvider
.NodeConverters
.Where(converter => converter.CanConvertNode(childNode))
.SelectMany(converter => converter.ConvertNode(childNode)));
var startingTagContent = "<" + ConvertToRazor(srcNode.Content.TrimStart('<'));
var startingTag = textNodeFactory.CreateTextNode(startingTagContent, CodeBlockNodeType.Opening);
var endingTag = textNodeFactory.CreateTextNode($"</{srcNode.TagName}>", CodeBlockNodeType.Closing);
return(new[] { startingTag }
.Concat(convertedChildren)
.Concat(new[] { endingTag })
.ToArray());
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var contentTag = node as IWebFormsServerControlNode;
var contentPlaceHolderID = contentTag.Attributes["ContentPlaceHolderID"];
var convertedChildren = new List <IRazorNode>();
foreach (var childNode in node.Children)
{
foreach (var converter in NodeConverterProvider.NodeConverters)
{
if (converter.CanConvertNode(childNode))
{
convertedChildren.AddRange(converter.ConvertNode(childNode));
}
}
}
if (string.Compare(contentPlaceHolderID, Configuration.BodyContentPlaceHolderID, true) != 0)
{
var sectionNode = SectionNodeFactory.CreateSectionNode(contentPlaceHolderID);
foreach (var convertedNode in convertedChildren)
{
sectionNode.Children.Add(convertedNode);
}
return(new IRazorSectionNode[] { sectionNode });
}
else
{
return(convertedChildren);
}
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsCodeBlockNode;
var requiresPrefix = srcNode.BlockType == CodeBlockNodeType.Complete || srcNode.BlockType == CodeBlockNodeType.Opening;
if ((node.Parent != null &&
(node.Parent.Type == NodeType.CodeBlock ||
node.Parent.Type == NodeType.EncodedExpressionBlock ||
node.Parent.Type == NodeType.ExpressionBlock)) ||
node is WebFormsCodeGroupNode)
{
requiresPrefix = false;
}
// Not implemented: Detection requires analysis of the C# code to determine if it contains more than one statement
// See CodeBlockConverterTests.Should_require_block_for_multi_statement_code_block
var requiresBlock = false;
var code = srcNode.Code;
code = ReplaceRenderPartial(code);
if (code.TrimStart().StartsWith("@"))
{
requiresPrefix = false;
}
var codeNode = CodeNodeFactory.CreateCodeNode(code, requiresPrefix, requiresBlock, srcNode.BlockType);
return(new IRazorNode[] { codeNode });
}
private void ApplyPostprocessingFilters(IWebFormsNode rootNode)
{
foreach (var filter in NodeFilterProvider.Filters)
{
FilterChildNodes(rootNode, filter);
}
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsTextNode;
var destNode = TextNodeFactory.CreateTextNode(srcNode.Text, CodeBlockNodeType.Complete);
return(new IRazorNode[] { destNode });
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsCodeBlockNode;
var requiresPrefix = srcNode.BlockType == CodeBlockNodeType.Complete || srcNode.BlockType == CodeBlockNodeType.Opening;
// Not implemented: Detection requires analysis of the C# code to determine if it contains more than one statement
// See CodeBlockConverterTests.Should_require_block_for_multi_statement_code_block
var requiresBlock = false;
var code = srcNode.Code;
foreach (var codeConverter in _converters)
{
code = codeConverter.ConvertCodeBlock(code);
}
code = ReplaceRenderPartial(code);
if (code.TrimStart().StartsWith("@"))
{
requiresPrefix = false;
}
var codeNode = CodeNodeFactory.CreateCodeNode(code, requiresPrefix, requiresBlock);
return(new IRazorNode[] { codeNode });
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var result = new List <IRazorNode>();
var directiveNode = node as IWebFormsDirectiveNode;
if (directiveNode != null)
{
var attributes = directiveNode.Attributes;
if (attributes.ContainsKey("inherits"))
{
AddModelOrInheritsDirective(attributes, result);
}
else if (attributes.ContainsKey("namespace") &&
directiveNode.Directive == DirectiveType.Import)
{
AddUsingDirective(attributes, result);
}
if (attributes.ContainsKey("masterpagefile"))
{
AddLayoutDirective(attributes, result);
}
}
return(result);
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var contentTag = node as IWebFormsServerControlNode;
var shouldRender = false;
var contentPlaceHolderID = string.Empty;
var convertedChildren = new List <IRazorNode>();
if (contentTag.Attributes.ContainsKey("ID") && contentTag.TagName.ToLower() == "asp:contentplaceholder")
{
shouldRender = true;
}
else
{
contentPlaceHolderID = contentTag.Attributes["ContentPlaceHolderID"];
}
Action <IEnumerable <IRazorNode>, IRazorNode> iterateOverChildrens = (childrens, parentNode) =>
{
foreach (var convertedNode in childrens)
{
parentNode.Children.Add(convertedNode);
}
};
foreach (var childNode in node.Children)
{
foreach (var converter in NodeConverterProvider.NodeConverters)
{
if (converter.CanConvertNode(childNode))
{
convertedChildren.AddRange(converter.ConvertNode(childNode));
}
}
}
IRazorSectionNode sectionNode = null;
if (shouldRender)
{
sectionNode = SectionNodeFactory.CreateSectionNode(contentTag.Attributes["ID"], true);
iterateOverChildrens(convertedChildren, sectionNode);
}
else if (string.Compare(contentPlaceHolderID, Configuration.BodyContentPlaceHolderID, true) != 0)
{
sectionNode = SectionNodeFactory.CreateSectionNode(contentPlaceHolderID);
iterateOverChildrens(convertedChildren, sectionNode);
}
if (sectionNode != null)
{
return(new IRazorSectionNode[] { sectionNode });
}
else
{
return(convertedChildren);
}
}
public void Should_parse_script_with_expression_content()
{
var script = @"<script type=""text/javascript"">alert('<%= Html.SomeText() %></gh>');</script>";
var document = parser.Parse(@"<asp:Content runat=""server"">" + script + @"</asp:Content>");
IWebFormsNode webFormsNode = document.RootNode.Children[0];
((IWebFormsTextNode)webFormsNode.Children[0]).Text.ShouldEqual(@"<script type=""text/javascript"">alert('");
((IWebFormsExpressionBlockNode)webFormsNode.Children[1]).Expression.Trim().ShouldEqual("Html.SomeText()");
((IWebFormsTextNode)webFormsNode.Children[2]).Text.ShouldEqual("</gh>');</script>");
}
public IList<IWebFormsNode> Filter(IWebFormsNode node, IWebFormsNode previousFilteredNode)
{
var isCodeGroupNode = node is IWebFormsCodeGroupNode;
if (isCodeGroupNode)
{
var codeContentNode = node as IWebFormsContentNode;
codeContentNode.Content = WrapNestedTemplates(codeContentNode.Content);
}
return new IWebFormsNode[] { node };
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsRawExpressionBlockNode;
var isMultiline = srcNode.Expression.Contains("\r") || srcNode.Expression.Contains("\n");
var expression = srcNode.Expression.Trim(new char[] { ' ', '\t' });
expression = expression.Replace("ResolveUrl", "Url.Content");
return(new IRazorNode[]
{
ExpressionNodeFactory.CreateExpressionNode(expression, isMultiline)
});
}
public IList <IWebFormsNode> Filter(IWebFormsNode node, IWebFormsNode previousFilteredNode)
{
var isCodeGroupNode = node is IWebFormsCodeGroupNode;
if (isCodeGroupNode)
{
var codeContentNode = node as IWebFormsContentNode;
codeContentNode.Content = WrapNestedTemplates(codeContentNode.Content);
}
return(new IWebFormsNode[] { node });
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var result = new List <IRazorNode>();
var directiveNode = node as IWebFormsDirectiveNode;
if (directiveNode != null)
{
if (directiveNode.Attributes.ContainsKey("inherits"))
{
// var MasterPageFile =
var inheritsFrom = directiveNode.Attributes["inherits"];
var viewPageGenericType = new Regex("(?:Ohio.Web.Config.Rendering.SubView|Ohio.Web.UI.Fusion.FusionView|SubView)<(?<type>.*)>");
var typeMatch = viewPageGenericType.Match(inheritsFrom);
if (typeMatch.Success)
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("model", typeMatch.Result("${type}")));
}
else if (inheritsFrom != "Ohio.Web.Config.Rendering.SubView" && inheritsFrom != "Ohio.Web.UI.Fusion.FusionView")
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("inherits", directiveNode.Attributes["inherits"]));
}
}
else if (directiveNode.Attributes.ContainsKey("namespace") &&
directiveNode.Directive == DirectiveType.Import)
{
/* Case of of a using directive */
var imports = directiveNode.Attributes["namespace"];
if (!string.IsNullOrEmpty(imports))
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("using", directiveNode.Attributes["namespace"]));
}
}
if (directiveNode.Attributes.ContainsKey("masterpagefile"))
{
var inheritsFrom = directiveNode.Attributes["masterpagefile"];
if (inheritsFrom.Contains("~/Fusion/Common/Master.master"))
{
result.Add(new RazorTextNode(Environment.NewLine + "@{Layout=\"~/Fusion/X/Master.cshtml\";}"));
}
}
}
return(result);
}
public bool CanConvertNode(IWebFormsNode node)
{
var serverControlNode = node as IWebFormsServerControlNode;
if (serverControlNode != null)
{
var tagName = serverControlNode.TagName.ToLowerInvariant();
return(tagName == "asp:content" || tagName == "asp:contentplaceholder");
}
else
{
return(false);
}
}
private void AppendTextNode(IWebFormsNode parentNode, Match match)
{
var currentTextNode = parentNode.Children.LastOrDefault() as IWebFormsTextNode;
if (currentTextNode == null)
{
currentTextNode = (IWebFormsTextNode)NodeFactory.CreateNode(match, NodeType.Text);
parentNode.Children.Add(currentTextNode);
}
else
{
currentTextNode.Text += match.Value;
}
}
public bool CanConvertNode(IWebFormsNode node)
{
var serverControlNode = node as IWebFormsServerControlNode;
if (serverControlNode == null)
{
return(false);
}
//|| serverControlNode.TagName.ToLowerInvariant() == "asp:contentplaceholder"
var z = serverControlNode.TagName.ToLowerInvariant() == "asp:content";
return(z);
}
public IList<IWebFormsNode> Filter(IWebFormsNode node, IWebFormsNode previousFilteredNode)
{
var isCodeGroupNode = node is IWebFormsCodeGroupNode;
var isCompleteCodeNode = node is IWebFormsCodeBlockNode && ((IWebFormsCodeBlockNode)node).BlockType == CodeBlockNodeType.Complete;
if (isCodeGroupNode || isCompleteCodeNode)
{
var codeContentNode = node as IWebFormsContentNode;
if (codeContentNode != null && RequiresBlock(codeContentNode.Content))
{
codeContentNode.Content = string.Format("{{{0}}}", codeContentNode.Content);
}
}
return new IWebFormsNode[] { node };
}
public IList <IWebFormsNode> Filter(IWebFormsNode node, IWebFormsNode previousFilteredNode)
{
var isCodeGroupNode = node is IWebFormsCodeGroupNode;
var isCompleteCodeNode = node is IWebFormsCodeBlockNode && ((IWebFormsCodeBlockNode)node).BlockType == CodeBlockNodeType.Complete;
if (isCodeGroupNode || isCompleteCodeNode)
{
var codeContentNode = node as IWebFormsContentNode;
if (codeContentNode != null && RequiresBlock(codeContentNode.Content))
{
codeContentNode.Content = string.Format("{{{0}}}", codeContentNode.Content);
}
}
return(new IWebFormsNode[] { node });
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsExpressionBlockNode;
var isMultiline = srcNode.Expression.Contains("\r") ||
srcNode.Expression.Contains("\n") ||
DoesExpressionContainsComplexLogic(srcNode);
var expression = srcNode.Expression.Trim(new char[] { ' ', '\t' });
expression = expression.Replace("ResolveUrl", "Url.Content");
expression = RemoveHtmlEncode(expression);
expression = WrapHtmlDecode(expression);
return(new IRazorNode[]
{
ExpressionNodeFactory.CreateExpressionNode(expression, isMultiline)
});
}
private IWebFormsCodeGroupNode FindLastOpenGroup(IWebFormsNode previousFilteredNode)
{
var groupNode = previousFilteredNode as IWebFormsCodeGroupNode;
if (groupNode != null)
{
var codeBlocks = groupNode.Children.Where(c => c is IWebFormsCodeBlockNode);
var openingBlocks = codeBlocks.Count(c => ((IWebFormsCodeBlockNode)c).BlockType == CodeBlockNodeType.Opening);
var closingBlocks = codeBlocks.Count(c => ((IWebFormsCodeBlockNode)c).BlockType == CodeBlockNodeType.Closing);
if (openingBlocks > 0 && openingBlocks != closingBlocks)
{
return groupNode;
}
}
return null;
}
private IWebFormsCodeGroupNode FindLastOpenGroup(IWebFormsNode previousFilteredNode)
{
var groupNode = previousFilteredNode as IWebFormsCodeGroupNode;
if (groupNode != null)
{
var codeBlocks = groupNode.Children.Where(c => c is IWebFormsCodeBlockNode);
var openingBlocks = codeBlocks.Count(c => ((IWebFormsCodeBlockNode)c).BlockType == CodeBlockNodeType.Opening);
var closingBlocks = codeBlocks.Count(c => ((IWebFormsCodeBlockNode)c).BlockType == CodeBlockNodeType.Closing);
if (openingBlocks > 0 && openingBlocks != closingBlocks)
{
return(groupNode);
}
}
return(null);
}
private void FilterChildNodes(IWebFormsNode rootNode, IWebFormsNodeFilter filter)
{
if (rootNode.Children.Count > 0)
{
var filterOutput = new List <IWebFormsNode>();
foreach (var childNode in rootNode.Children)
{
FilterChildNodes(childNode, filter);
filterOutput.AddRange(filter.Filter(childNode, filterOutput.LastOrDefault()));
}
rootNode.Children.Clear();
foreach (var filteredNode in filterOutput)
{
rootNode.Children.Add(filteredNode);
}
}
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var srcNode = node as IWebFormsExpressionBlockNode;
var isMultiline = srcNode.Expression.Contains("\r") || srcNode.Expression.Contains("\n");
var expression = srcNode.Expression.Trim(new char[] { ' ', '\t' });
expression = expression.Replace("ResolveUrl", "Url.Content");
expression = RemoveHtmlEncode(expression);
expression = WrapHtmlDecode(expression);
foreach (var codeConverter in _converters)
{
expression = codeConverter.ConvertCodeBlock(expression);
}
return(new IRazorNode[]
{
ExpressionNodeFactory.CreateExpressionNode(expression, isMultiline)
});
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var result = new List <IRazorNode>();
foreach (var childNode in node.Children)
{
foreach (var converter in NodeConverterProvider.NodeConverters)
{
if (converter.CanConvertNode(childNode))
{
foreach (var convertedChildNode in converter.ConvertNode(childNode))
{
result.Add(convertedChildNode);
}
}
}
}
return(result);
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var result = new List <IRazorNode>();
var directiveNode = node as IWebFormsDirectiveNode;
if (directiveNode != null)
{
if (directiveNode.Attributes.ContainsKey("inherits"))
{
var inheritsFrom = directiveNode.Attributes["inherits"];
var viewPageGenericType = new Regex("System.Web.Mvc.(?:ViewPage|ViewUserControl)<(?<type>.*)>");
var typeMatch = viewPageGenericType.Match(inheritsFrom);
if (typeMatch.Success)
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("model", typeMatch.Result("${type}")));
}
else if (inheritsFrom != "System.Web.Mvc.ViewPage" && inheritsFrom != "System.Web.Mvc.ViewUserControl")
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("inherits", directiveNode.Attributes["inherits"]));
}
}
else if (directiveNode.Attributes.ContainsKey("namespace") &&
directiveNode.Directive == DirectiveType.Import)
{
/* Case of of a using directive */
var imports = directiveNode.Attributes["namespace"];
if (!string.IsNullOrEmpty(imports))
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("using", directiveNode.Attributes["namespace"]));
}
}
}
return(result);
}
public IList<IWebFormsNode> Filter(IWebFormsNode node, IWebFormsNode previousFilteredNode)
{
var codeNode = node as IWebFormsCodeBlockNode;
var lastGroup = FindLastOpenGroup(previousFilteredNode);
var result = new List<IWebFormsNode>();
if (lastGroup != null)
{
lastGroup.Children.Add(node);
}
else
{
if (codeNode != null && codeNode.BlockType == CodeBlockNodeType.Opening)
{
result.Add(MultiPartNodeFactory.CreatCodeGroupNode(codeNode));
}
else
{
result.Add(node);
}
}
return result;
}
public IList <IRazorNode> ConvertNode(IWebFormsNode node)
{
var result = new List <IRazorNode>();
var directiveNode = node as IWebFormsDirectiveNode;
if (directiveNode != null &&
directiveNode.Attributes.ContainsKey("inherits"))
{
var inheritsFrom = directiveNode.Attributes["inherits"];
var viewPageGenericType = new Regex("System.Web.Mvc.(?:ViewPage|ViewUserControl)<(?<type>.*)>");
var typeMatch = viewPageGenericType.Match(inheritsFrom);
if (typeMatch.Success)
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("model", typeMatch.Result("${type}")));
}
else if (inheritsFrom != "System.Web.Mvc.ViewPage" && inheritsFrom != "System.Web.Mvc.ViewUserControl")
{
result.Add(DirectiveNodeFactory.CreateDirectiveNode("inherits", directiveNode.Attributes["inherits"]));
}
}
return(result);
}
public IList <IWebFormsNode> Filter(IWebFormsNode node, IWebFormsNode previousFilteredNode)
{
var codeNode = node as IWebFormsCodeBlockNode;
var lastGroup = FindLastOpenGroup(previousFilteredNode);
var result = new List <IWebFormsNode>();
if (lastGroup != null)
{
lastGroup.Children.Add(node);
}
else
{
if (codeNode != null && codeNode.BlockType == CodeBlockNodeType.Opening)
{
result.Add(MultiPartNodeFactory.CreatCodeGroupNode(codeNode));
}
else
{
result.Add(node);
}
}
return(result);
}
public bool CanConvertNode(IWebFormsNode node)
{
return(node is IWebFormsTextNode);
}
private void FilterChildNodes(IWebFormsNode rootNode, IWebFormsNodeFilter filter)
{
if (rootNode.Children.Count > 0)
{
var filterOutput = new List<IWebFormsNode>();
foreach (var childNode in rootNode.Children)
{
FilterChildNodes(childNode, filter);
filterOutput.AddRange(filter.Filter(childNode, filterOutput.LastOrDefault()));
}
rootNode.Children.Clear();
foreach (var filteredNode in filterOutput)
{
rootNode.Children.Add(filteredNode);
}
}
}
public bool CanConvertNode(IWebFormsNode node)
{
return(node is IWebFormsCodeBlockNode);
}
private void ApplyPostprocessingFilters(IWebFormsNode rootNode)
{
foreach (var filter in NodeFilterProvider.Filters)
{
FilterChildNodes(rootNode, filter);
}
}
private void AppendTextNode(IWebFormsNode parentNode, Match match)
{
var currentTextNode = parentNode.Children.LastOrDefault() as IWebFormsTextNode;
if (currentTextNode == null)
{
currentTextNode = (IWebFormsTextNode) NodeFactory.CreateNode(match, NodeType.Text);
parentNode.Children.Add(currentTextNode);
}
else
{
currentTextNode.Text += match.Value;
}
}
public bool CanConvertNode(IWebFormsNode node)
{
var serverControlNode = node as IWebFormsServerControlNode;
return(serverControlNode != null && serverControlNode.TagName.ToLowerInvariant() == "asp:content");
}
public IDocument <IWebFormsNode> Parse(string input)
{
Match match;
int startAt = 0;
var root = new WebFormsNode {
Type = NodeType.Document
};
IWebFormsNode parentNode = root;
do
{
if ((match = textRegex.Match(input, startAt)).Success)
{
AppendTextNode(parentNode, match);
startAt = match.Index + match.Length;
}
if (startAt != input.Length)
{
if ((match = directiveRegex.Match(input, startAt)).Success)
{
var directiveNode = NodeFactory.CreateNode(match, NodeType.Directive);
parentNode.Children.Add(directiveNode);
}
else if ((match = commentRegex.Match(input, startAt)).Success)
{
var commentNode = NodeFactory.CreateNode(match, NodeType.Comment);
parentNode.Children.Add(commentNode);
}
else if ((match = runatServerTagRegex.Match(input, startAt)).Success)
{
var serverControlNode = NodeFactory.CreateNode(match, NodeType.ServerControl);
parentNode.Children.Add(serverControlNode);
if (!match.Value.EndsWith("/>"))
{
parentNode = serverControlNode;
}
}
else if ((match = doctypeRegex.Match(input, startAt)).Success)
{
AppendTextNode(parentNode, match);
}
else if ((match = startTagOpeningBracketRegex.Match(input, startAt)).Success)
{
AppendTextNode(parentNode, match);
}
else if ((match = endTagRegex.Match(input, startAt)).Success)
{
var tagName = match.Groups["tagname"].Captures[0].Value;
var serverControlParent = parentNode as IWebFormsServerControlNode;
if (serverControlParent != null && tagName.ToLowerInvariant() == serverControlParent.TagName.ToLowerInvariant())
{
parentNode = parentNode.Parent;
}
else
{
AppendTextNode(parentNode, match);
}
}
else if ((match = aspExprRegex.Match(input, startAt)).Success || (match = aspEncodedExprRegex.Match(input, startAt)).Success)
{
var expressionBlockNode = NodeFactory.CreateNode(match, NodeType.ExpressionBlock);
parentNode.Children.Add(expressionBlockNode);
}
else if ((match = aspCodeRegex.Match(input, startAt)).Success)
{
var codeBlockNode = NodeFactory.CreateNode(match, NodeType.CodeBlock);
parentNode.Children.Add(codeBlockNode);
}
else if ((match = scriptRegex.Match(input, startAt)).Success) // Relocated to enable processing of <% %> tags within the script block.
{
AppendTextNode(parentNode, match);
}
else
{
throw new Exception(
string.Format("Unrecognized page element: {0}...", input.Substring(startAt, 20)));
}
startAt = match.Index + match.Length;
}
}while (startAt != input.Length);
ApplyPostprocessingFilters(root);
return(new Document <IWebFormsNode>(root));
}
public bool CanConvertNode(IWebFormsNode node)
{
return(node is IWebFormsExpressionBlockNode);
}
