/// <summary>Creates the pseudo node.</summary> /// <param name="pseudoTree">The pseudo tree.</param> /// <returns>The pseudo node.</returns> private static PseudoNode CreatePseudoNode(CommonTree pseudoTree) { return(pseudoTree == null ? null : new PseudoNode( pseudoTree.GrandChildren(T(CssParser.COLONS)).Count(), pseudoTree.Children(T(CssParser.PSEUDONAME)).FirstChildText(), CreateFunctionalPseudoNode(pseudoTree.Children(T(CssParser.FUNCTIONAL_PSEUDO)).FirstOrDefault()))); }
/// <summary>Creates the attrib node.</summary> /// <param name="attribTree">The attrib tree.</param> /// <returns>The attrib node.</returns> private static AttribNode CreateAttribNode(CommonTree attribTree) { return(attribTree == null ? null : new AttribNode( CreateNamespacePrefixNode(attribTree.Children(T(CssParser.SELECTOR_NAMESPACE_PREFIX)).FirstOrDefault()), attribTree.Children(T(CssParser.ATTRIBNAME)).FirstChildText(), CreateAttribOperatorValueNode(attribTree.Children(T(CssParser.ATTRIBOPERATORVALUE)).FirstOrDefault()))); }
/// <summary>Creates the simple selector.</summary> /// <param name="simpleSelectorSequenceTree">The simple selector.</param> /// <returns>The simple selector node.</returns> private static SimpleSelectorSequenceNode CreateSimpleSelectorSequenceNode(CommonTree simpleSelectorSequenceTree) { return(simpleSelectorSequenceTree == null ? null : new SimpleSelectorSequenceNode( CreateTypeSelectorNode(simpleSelectorSequenceTree.Children(T(CssParser.TYPE_SELECTOR)).FirstOrDefault()), CreateUniversalSelectorNode(simpleSelectorSequenceTree.Children(T(CssParser.UNIVERSAL)).FirstOrDefault()), GetWhitespaceCount(simpleSelectorSequenceTree) > 0 ? CssConstants.SingleSpace.ToString() : null, CreateHashClassAttribPseudoNegationNodes(simpleSelectorSequenceTree.GrandChildren(T(CssParser.HASHCLASSATNAMEATTRIBPSEUDONEGATIONNODES))).ToSafeReadOnlyCollection())); }
/// <summary>Creates the key frame node.</summary> /// <param name="styleSheetChild">The style sheet child.</param> /// <returns>The key frame node.</returns> private static KeyFramesNode CreateKeyFramesNode(CommonTree styleSheetChild) { return(new KeyFramesNode( styleSheetChild.Children(T(CssParser.KEYFRAMES_SYMBOL)).FirstChildText(), styleSheetChild.Children(T(CssParser.IDENTBASEDVALUE)).FirstChildText(), StringOrUriBasedValue(styleSheetChild.Children(T(CssParser.STRINGBASEDVALUE)).FirstChildText()), styleSheetChild.GrandChildren(T(CssParser.KEYFRAMES_BLOCKS)).Select(CreateKeyFramesBlockNode).ToSafeReadOnlyCollection())); }
/// <summary>Creates the media query node.</summary> /// <param name="mediaQueryTree">The media query tree.</param> /// <returns>The media query node.</returns> private static MediaQueryNode CreateMediaQueryNode(CommonTree mediaQueryTree) { return(new MediaQueryNode( mediaQueryTree.Children(T(CssParser.ONLY_TEXT)).FirstChildText(), mediaQueryTree.Children(T(CssParser.NOT_TEXT)).FirstChildText(), mediaQueryTree.Children(T(CssParser.MEDIA_TYPE)).FirstChildText(), mediaQueryTree.GrandChildren(T(CssParser.MEDIA_EXPRESSIONS)).Select(CreateMediaExpressionNode).ToSafeReadOnlyCollection())); }
/// <summary>Creates the function node.</summary> /// <param name="functionTree">The function tree.</param> /// <returns>The function node.</returns> private static FunctionNode CreateFunctionNode(CommonTree functionTree) { if (functionTree == null) { return(null); } return(new FunctionNode( functionTree.Children(T(CssParser.FUNCTIONNAME)).FirstChildText(), CreateExpressionNode(functionTree.Children(T(CssParser.EXPR)).FirstOrDefault()))); }
/// <summary>Creates the attrib operator value node.</summary> /// <param name="attribOperatorAndValueTree">The attrib operator and value tree.</param> /// <returns>The attrib operator value node.</returns> private static AttribOperatorAndValueNode CreateAttribOperatorValueNode(CommonTree attribOperatorAndValueTree) { if (attribOperatorAndValueTree == null) { return(null); } // The operator node var attribOperatorKind = AttribOperatorKind.None; switch (attribOperatorAndValueTree.Children(T(CssParser.ATTRIBOPERATOR)).FirstChildText()) { case CssConstants.PrefixMatch: attribOperatorKind = AttribOperatorKind.Prefix; break; case CssConstants.SuffixMatch: attribOperatorKind = AttribOperatorKind.Suffix; break; case CssConstants.SubstringMatch: attribOperatorKind = AttribOperatorKind.Substring; break; case CssConstants.Equal: attribOperatorKind = AttribOperatorKind.Equal; break; case CssConstants.Includes: attribOperatorKind = AttribOperatorKind.Includes; break; case CssConstants.DashMatch: attribOperatorKind = AttribOperatorKind.DashMatch; break; } // The operator value node string attribValue = null; var attribValueNode = attribOperatorAndValueTree.Children(T(CssParser.ATTRIBVALUE)).FirstOrDefault(); if (attribValueNode != null) { attribValue = attribValueNode.FirstChildText() == T(CssParser.STRINGBASEDVALUE) ? StringOrUriBasedValue(attribValueNode.Children(T(CssParser.STRINGBASEDVALUE)).FirstChildText()) : attribValueNode.FirstChildText(); } return(new AttribOperatorAndValueNode(attribOperatorKind, attribValue)); }
/// <summary> /// Creates the document query node. /// </summary> /// <param name="documentTree">tree with document descendants</param> /// <returns>new instance of document query node</returns> private static DocumentQueryNode CreateDocumentQueryNode(CommonTree documentTree) { return(new DocumentQueryNode( string.Join(string.Empty, documentTree.GrandChildren(T(CssParser.DOCUMENT_MATCHNAME)).Select(_ => _.Text)), documentTree.Children(T(CssParser.DOCUMENT_SYMBOL)).FirstChildText(), documentTree.GrandChildren(T(CssParser.RULESETS)).Select(CreateRulesetNode).ToSafeReadOnlyCollection())); }
/// <summary>Gets the whitespace count.</summary> /// <param name="commonTree">The common tree.</param> /// <returns>The whitespace count.</returns> private static int GetWhitespaceCount(CommonTree commonTree) { Contract.Requires(commonTree != null); var whitespaceChildText = commonTree.Children(T(CssParser.WHITESPACE)).FirstChildText(); int count; return(int.TryParse(whitespaceChildText, out count) ? count : 0); }
/// <summary>Creates the charset node.</summary> /// <param name="styleSheetTree">The styleSheet tree.</param> /// <returns>The charset value.</returns> private static string CreateCharsetNode(CommonTree styleSheetTree) { if (styleSheetTree == null) { return(null); } var charset = styleSheetTree.Children(T(CssParser.CHARSET)).FirstOrDefault(); return(charset != null?StringOrUriBasedValue(charset.Children(T(CssParser.STRINGBASEDVALUE)).FirstChildText()) : null); }
public static IEnumerable <CommonTree> GrandChildren(this CommonTree commonTree, string childFilterText) { if (commonTree == null || commonTree.Children == null) { yield break; } foreach (var granchChild in commonTree.Children(childFilterText).SelectMany(_ => _.Children())) { yield return(granchChild); } }
/// <summary>Creates the expression node</summary> /// <param name="exprTree">The expression tree.</param> /// <returns>The expression node.</returns> private static ExprNode CreateExpressionNode(CommonTree exprTree) { if (exprTree == null) { return(null); } return(new ExprNode( CreateTermNode(exprTree.Children(T(CssParser.TERM)).FirstOrDefault()), CreateTermWithOperatorsNode(exprTree.GrandChildren(T(CssParser.TERMWITHOPERATORS))).ToSafeReadOnlyCollection(), CreateImportantCommentNodes(exprTree))); }
/// <summary>The create styleSheet node.</summary> /// <param name="commonTree">The common tree.</param> /// <returns>The styleSheet node.</returns> internal static StyleSheetNode CreateStyleSheetNode(CommonTree commonTree) { Contract.Requires(commonTree != null); var styleSheetTree = commonTree.Children(T(CssParser.STYLESHEET)).FirstOrDefault(); return(new StyleSheetNode( CreateCharsetNode(styleSheetTree), CreateImportNodes(styleSheetTree), CreateNamespaceNodes(styleSheetTree), CreateStyleSheetRulesNodes(styleSheetTree))); }
/// <summary>Gets the text of first child or default value.</summary> /// <param name="commonTree">The common tree.</param> /// <param name="defaultText">The default text.</param> /// <returns>The first child text.</returns> public static string FirstChildTextOrDefault(this CommonTree commonTree, string defaultText = null) { if (commonTree != null) { var firstChild = commonTree.Children().FirstOrDefault(); if (firstChild != null) { return(firstChild.TextOrDefault(defaultText)); } } return(defaultText); }
/// <summary>Creates the negation arg node.</summary> /// <param name="negationArgTree">The negation arg tree.</param> /// <returns>The negation arg node.</returns> private static NegationArgNode CreateNegationArgNode(CommonTree negationArgTree) { return(negationArgTree == null ? null : new NegationArgNode( CreateTypeSelectorNode( negationArgTree.Children(T(CssParser.TYPE_SELECTOR)).FirstOrDefault()), CreateUniversalSelectorNode(negationArgTree.Children(T(CssParser.UNIVERSAL)).FirstOrDefault()), negationArgTree.Children(T(CssParser.HASHIDENTIFIER)).FirstChildText(), negationArgTree.Children(T(CssParser.CLASSIDENTIFIER)).FirstChildText(), CreateAttribNode(negationArgTree.Children(T(CssParser.ATTRIBIDENTIFIER)).FirstOrDefault()), CreatePseudoNode(negationArgTree.Children(T(CssParser.PSEUDOIDENTIFIER)).FirstOrDefault()))); }
/// <summary>Gets the ruleset media page nodes.</summary> /// <param name="styleSheetTree">The styleSheet common tree.</param> /// <returns>The list of ruleset media page nodes.</returns> private static ReadOnlyCollection <StyleSheetRuleNode> CreateStyleSheetRulesNodes(CommonTree styleSheetTree) { if (styleSheetTree == null) { return(Enumerable.Empty <StyleSheetRuleNode>().ToSafeReadOnlyCollection()); } var ruleSetMediaPageNodes = new List <StyleSheetRuleNode>(); foreach (var styleSheetChild in styleSheetTree.Children()) { if (styleSheetChild.Text == T(CssParser.RULESET)) { ruleSetMediaPageNodes.Add(CreateRulesetNode(styleSheetChild)); } else if (styleSheetChild.Text == T(CssParser.MEDIA)) { ruleSetMediaPageNodes.Add(CreateMediaNode(styleSheetChild)); } else if (styleSheetChild.Text == T(CssParser.PAGE)) { ruleSetMediaPageNodes.Add(CreatePageNode(styleSheetChild)); } else if (styleSheetChild.Text == T(CssParser.KEYFRAMES)) { ruleSetMediaPageNodes.Add(CreateKeyFramesNode(styleSheetChild)); } else if (styleSheetChild.Text == T(CssParser.DOCUMENT)) { ruleSetMediaPageNodes.Add(CreateDocumentQueryNode(styleSheetChild)); } else if (styleSheetChild.Type.Equals(CssParser.IMPORTANT_COMMENTS)) { ruleSetMediaPageNodes.Add(new StyleSheetRuleOrCommentNode(new ImportantCommentNode(styleSheetChild.Text), true)); } } return(ruleSetMediaPageNodes.AsReadOnly()); }
/// <summary>Creates the term node.</summary> /// <param name="termTree">The term tree.</param> /// <returns>The term node.</returns> private static TermNode CreateTermNode(CommonTree termTree) { if (termTree == null) { return(null); } // Unary var unaryOperator = termTree.Children(T(CssParser.UNARY)).FirstChildText(); // Number based value var numberBasedValue = termTree.Children(T(CssParser.NUMBERBASEDVALUE)).FirstChildText(); // Token value var replacementTokenBasedValue = termTree.Children(T(CssParser.REPLACEMENTTOKENBASEDVALUE)).FirstChildText(); // Url based value var uriStringOrIdentBasedValue = StringOrUriBasedValue(termTree.Children(T(CssParser.URIBASEDVALUE)).FirstChildText()); // String based value if (string.IsNullOrWhiteSpace(uriStringOrIdentBasedValue)) { uriStringOrIdentBasedValue = StringOrUriBasedValue(termTree.Children(T(CssParser.STRINGBASEDVALUE)).FirstChildText()); } // Ident based value if (string.IsNullOrWhiteSpace(uriStringOrIdentBasedValue)) { uriStringOrIdentBasedValue = StringOrUriBasedValue(termTree.Children(T(CssParser.IDENTBASEDVALUE)).FirstChildText()); } // Hex based value var hexBasedNode = termTree.Children(T(CssParser.HEXBASEDVALUE)).FirstOrDefault(); var hexBasedValue = hexBasedNode != null?hexBasedNode.Children(T(CssParser.HASHIDENTIFIER)).FirstChildText() : null; // Comments var comments = CreateImportantCommentNodes(termTree); return(new TermNode(unaryOperator, numberBasedValue, uriStringOrIdentBasedValue, hexBasedValue, CreateFunctionNode(termTree.Children(T(CssParser.FUNCTIONBASEDVALUE)).FirstOrDefault()), comments, replacementTokenBasedValue)); }
/// <summary>Creates the type selector node.</summary> /// <param name="typeSelectorTree">The common tree.</param> /// <returns>The type selectoe node.</returns> private static TypeSelectorNode CreateTypeSelectorNode(CommonTree typeSelectorTree) { return(typeSelectorTree == null ? null : new TypeSelectorNode( CreateNamespacePrefixNode(typeSelectorTree.Children(T(CssParser.SELECTOR_NAMESPACE_PREFIX)).FirstOrDefault()), typeSelectorTree.Children(T(CssParser.ELEMENT_NAME)).FirstChildText())); }
/// <summary>Creates the universal selector node.</summary> /// <param name="universalSelectorTree">The universal selector tree.</param> /// <returns>The universal selector node.</returns> private static UniversalSelectorNode CreateUniversalSelectorNode(CommonTree universalSelectorTree) { return(universalSelectorTree == null ? null : new UniversalSelectorNode( CreateNamespacePrefixNode(universalSelectorTree.Children(T(CssParser.SELECTOR_NAMESPACE_PREFIX)).FirstOrDefault()))); }
/// <summary>Creates the media expression node.</summary> /// <param name="mediaExpressionTree">The media expression tree.</param> /// <returns>The media expression node.</returns> private static MediaExpressionNode CreateMediaExpressionNode(CommonTree mediaExpressionTree) { return(new MediaExpressionNode( mediaExpressionTree.Children(T(CssParser.MEDIA_FEATURE)).FirstChildText(), CreateExpressionNode(mediaExpressionTree.Children(T(CssParser.EXPR)).FirstOrDefault()))); }
/// <summary>Creates the selector expression node.</summary> /// <param name="selectorExpressionTree">The selector expression tree.</param> /// <returns>The selector expression node.</returns> private static SelectorExpressionNode CreateSelectorExpressionNode(CommonTree selectorExpressionTree) { return(selectorExpressionTree == null ? null : new SelectorExpressionNode( selectorExpressionTree.Children().Select(_ => _.TextOrDefault()).ToSafeReadOnlyCollection())); }
/// <summary>Creates the functional pseudo tree.</summary> /// <param name="functionalPseudoTree">The functional pseudo tree.</param> /// <returns>The functional pseudo node.</returns> private static FunctionalPseudoNode CreateFunctionalPseudoNode(CommonTree functionalPseudoTree) { return(functionalPseudoTree == null ? null : new FunctionalPseudoNode( functionalPseudoTree.Children(T(CssParser.FUNCTIONNAME)).FirstChildText(), CreateSelectorExpressionNode(functionalPseudoTree.Children(T(CssParser.SELECTOR_EXPRESSION)).FirstOrDefault()))); }
/// <summary>Creates the namespace prefix node.</summary> /// <param name="namespacePrefixTree">The namespace prefix tree.</param> /// <returns>The namespace prefix node.</returns> private static SelectorNamespacePrefixNode CreateNamespacePrefixNode(CommonTree namespacePrefixTree) { return(namespacePrefixTree == null ? null : new SelectorNamespacePrefixNode( namespacePrefixTree.Children(T(CssParser.ELEMENT_NAME)).FirstChildTextOrDefault(string.Empty))); }
/// <summary>Creates the negation node.</summary> /// <param name="negationTree">The negation tree.</param> /// <returns>The negation node.</returns> private static NegationNode CreateNegationNode(CommonTree negationTree) { return(negationTree == null ? null : new NegationNode( CreateNegationArgNode(negationTree.Children(T(CssParser.NEGATION_ARG)).FirstOrDefault()))); }