internal SelectorFactory ResetFactory()
{
_attributeName = null;
_attributeValue = null;
_attributeOperator = string.Empty;
_selectorOperation = SelectorOperation.Data;
_combinator = Combinator.Descendent;
_hasCombinator = false;
_currentSelector = null;
_aggregateSelectorList = null;
_complexSelector = null;
return(this);
}
private void ParseAttributeEnd(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.Data;
if (token.GrammarSegment != GrammarSegment.SquareBracketClose)
{
return;
}
switch (_attributeOperator)
{
case "=":
Insert(SimpleSelector.AttributeMatch(_attributeName, _attributeValue));
break;
case "~=":
Insert(SimpleSelector.AttributeSpaceSeparated(_attributeName, _attributeValue));
break;
case "|=":
Insert(SimpleSelector.AttributeDashSeparated(_attributeName, _attributeValue));
break;
case "^=":
Insert(SimpleSelector.AttributeStartsWith(_attributeName, _attributeValue));
break;
case "$=":
Insert(SimpleSelector.AttributeEndsWith(_attributeName, _attributeValue));
break;
case "*=":
Insert(SimpleSelector.AttributeContains(_attributeName, _attributeValue));
break;
case "!=":
Insert(SimpleSelector.AttributeNegatedMatch(_attributeName, _attributeValue));
break;
default:
Insert(SimpleSelector.AttributeUnmatched(_attributeName));
break;
}
}
private void ParseSymbol(Block token)
{
switch (token.GrammarSegment)
{
// Attribute [A]
case GrammarSegment.SquareBraceOpen:
_attributeName = null;
_attributeValue = null;
_attributeOperator = string.Empty;
_selectorOperation = SelectorOperation.Attribute;
return;
// Pseudo :P
case GrammarSegment.Colon:
_selectorOperation = SelectorOperation.PseudoClass;
return;
// ID #I
case GrammarSegment.Hash:
Insert(new IdSelector(((SymbolBlock)token).Value));
return;
// Type E
case GrammarSegment.Ident:
//this feels a little dirt
InsertElementWithOptionalClasses(((SymbolBlock)token).Value);
return;
// Whitespace
case GrammarSegment.Whitespace:
Insert(Combinator.Descendent);
return;
case GrammarSegment.Delimiter:
ParseDelimiter(token);
return;
case GrammarSegment.Comma:
InsertCommaDelimited();
return;
}
}
private void ParseAttributeOperator(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.AttributeValue;
if (token.GrammarSegment == GrammarSegment.SquareBracketClose)
{
ParseAttributeEnd(token);
}
else if (token is MatchBlock || token.GrammarSegment == GrammarSegment.Delimiter)
{
_attributeOperator = token.ToString();
}
else
{
_selectorOperation = SelectorOperation.AttributeEnd;
}
}
private void ParsePseudoElement(Block token)
{
_selectorOperation = SelectorOperation.Data;
if (token.GrammarSegment != GrammarSegment.Ident)
{
return;
}
var data = ((SymbolBlock)token).Value;
switch (data)
{
case PseudoSelectorPrefix.PseudoElementBefore:
Insert(SimpleSelector.PseudoElement(PseudoSelectorPrefix.PseudoElementBefore));
break;
case PseudoSelectorPrefix.PseudoElementAfter:
Insert(SimpleSelector.PseudoElement(PseudoSelectorPrefix.PseudoElementAfter));
break;
case PseudoSelectorPrefix.PseudoElementSelection:
Insert(SimpleSelector.PseudoElement(PseudoSelectorPrefix.PseudoElementSelection));
break;
case PseudoSelectorPrefix.PseudoElementFirstline:
Insert(SimpleSelector.PseudoElement(PseudoSelectorPrefix.PseudoElementFirstline));
break;
case PseudoSelectorPrefix.PseudoElementFirstletter:
Insert(SimpleSelector.PseudoElement(PseudoSelectorPrefix.PseudoElementFirstletter));
break;
default:
Insert(SimpleSelector.PseudoElement(data));
break;
}
}
private void ParseAttribute(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.AttributeOperator;
switch (token.GrammarSegment)
{
case GrammarSegment.Ident:
_attributeName = ((SymbolBlock)token).Value;
break;
case GrammarSegment.String:
_attributeName = ((StringBlock)token).Value;
break;
default:
_selectorOperation = SelectorOperation.Data;
break;
}
}
private void ParseDelimiter(Block token)
{
switch (((DelimiterBlock)token).Value)
{
case Specification.Comma:
InsertCommaDelimited();
return;
case Specification.GreaterThan:
Insert(Combinator.Child);
return;
case Specification.PlusSign:
Insert(Combinator.AdjacentSibling);
return;
case Specification.Tilde:
Insert(Combinator.Sibling);
return;
case Specification.Asterisk:
Insert(AllSelector.All());
return;
case Specification.Period:
_selectorOperation = SelectorOperation.Class;
return;
case Specification.Pipe:
Insert(Combinator.Namespace);
return;
}
}
private void ParseSymbol(Block token)
{
switch (token.GrammarSegment)
{
// Attribute [A]
case GrammarSegment.SquareBraceOpen:
_attributeName = null;
_attributeValue = null;
_attributeOperator = string.Empty;
_selectorOperation = SelectorOperation.Attribute;
return;
// Pseudo :P
case GrammarSegment.Colon:
_selectorOperation = SelectorOperation.PseudoClass;
return;
// ID #I
case GrammarSegment.Hash:
Insert(AttributeRestriction.Id(((SymbolBlock)token).Value));
return;
// Type E
case GrammarSegment.Ident:
Insert(ElementRestriction.LocalName(((SymbolBlock)token).Value));
return;
// Whitespace
case GrammarSegment.Whitespace:
Insert(Combinator.Descendent);
return;
case GrammarSegment.Delimiter:
ParseDelimiter(token);
return;
case GrammarSegment.Comma:
InsertCommaDelimited();
return;
}
}
private void ParsePseudoClassFunction(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
switch (_attributeName)
{
case PseudoSelectorPrefix.PseudoFunctionNthchild:
case PseudoSelectorPrefix.PseudoFunctionNthlastchild:
case PseudoSelectorPrefix.PseudoFunctionNthOfType:
case PseudoSelectorPrefix.PseudoFunctionNthLastOfType:
{
switch (token.GrammarSegment)
{
case GrammarSegment.Ident:
case GrammarSegment.Number:
case GrammarSegment.Dimension:
_attributeValue += token.ToString();
return;
case GrammarSegment.Delimiter:
var chr = ((DelimiterBlock)token).Value;
if (chr == Specification.PlusSign || chr == Specification.MinusSign)
{
_attributeValue += chr;
return;
}
break;
}
break;
}
case PseudoSelectorPrefix.PseudoFunctionNot:
{
if (_nestedSelectorFactory == null)
{
_nestedSelectorFactory = new SelectorFactory();
}
if (token.GrammarSegment != GrammarSegment.ParenClose || _nestedSelectorFactory._selectorOperation != SelectorOperation.Data)
{
_nestedSelectorFactory.Apply(token);
return;
}
break;
}
case PseudoSelectorPrefix.PseudoFunctionDir:
{
if (token.GrammarSegment == GrammarSegment.Ident)
{
_attributeValue = ((SymbolBlock)token).Value;
}
_selectorOperation = SelectorOperation.PseudoClassFunctionEnd;
return;
}
case PseudoSelectorPrefix.PseudoFunctionLang:
{
if (token.GrammarSegment == GrammarSegment.Ident)
{
_attributeValue = ((SymbolBlock)token).Value;
}
_selectorOperation = SelectorOperation.PseudoClassFunctionEnd;
return;
}
case PseudoSelectorPrefix.PseudoFunctionContains:
{
switch (token.GrammarSegment)
{
case GrammarSegment.String:
_attributeValue = ((StringBlock)token).Value;
break;
case GrammarSegment.Ident:
_attributeValue = ((SymbolBlock)token).Value;
break;
}
_selectorOperation = SelectorOperation.PseudoClassFunctionEnd;
return;
}
}
PrasePseudoClassFunctionEnd(token);
}
private void ParseClass(Block token)
{
_selectorOperation = SelectorOperation.Data;
if (token.GrammarSegment == GrammarSegment.Ident)
{
Insert(AttributeRestriction.Class(((SymbolBlock)token).Value));
}
}
private void ParsePseudoClass(Block token)
{
_selectorOperation = SelectorOperation.Data;
switch (token.GrammarSegment)
{
case GrammarSegment.Colon:
_selectorOperation = SelectorOperation.PseudoElement;
break;
case GrammarSegment.Function:
_attributeName = ((SymbolBlock)token).Value;
_attributeValue = string.Empty;
_selectorOperation = SelectorOperation.PseudoClassFunction;
if (_nestedSelectorFactory != null)
{
_nestedSelectorFactory.ResetFactory();
}
break;
case GrammarSegment.Ident:
var pseudoSelector = GetPseudoSelector(token);
if (pseudoSelector != null)
{
Insert(pseudoSelector);
}
break;
}
}
private void ParseAttributeEnd(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.Data;
if (token.GrammarSegment != GrammarSegment.SquareBracketClose)
{
return;
}
switch (_attributeOperator)
{
case "=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.Equals, Value = _attributeValue});
break;
case "~=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.WhitespaceListContains, Value = _attributeValue });
break;
case "|=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.HyphenatedListStartsWith, Value = _attributeValue });
break;
case "^=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.StartsWith, Value = _attributeValue });
break;
case "$=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.EndsWith, Value = _attributeValue });
break;
case "*=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.Contains, Value = _attributeValue });
break;
case "!=":
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.NotEquals, Value = _attributeValue });
break;
default:
Insert(new AttributeRestriction(_attributeName) { Comparison = AttributeComparison.Exists });
break;
}
}
private void ParseAttributeValue(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.AttributeEnd;
switch (token.GrammarSegment)
{
case GrammarSegment.Ident:
_attributeValue = ((SymbolBlock)token).Value;
break;
case GrammarSegment.String:
_attributeValue = ((StringBlock)token).Value;
break;
case GrammarSegment.Number:
_attributeValue = ((NumericBlock)token).Value.ToString(CultureInfo.InvariantCulture);
break;
default:
_selectorOperation = SelectorOperation.Data;
break;
}
}
private void ParseAttributeOperator(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.AttributeValue;
if (token.GrammarSegment == GrammarSegment.SquareBracketClose)
{
ParseAttributeEnd(token);
}
else if (token is MatchBlock || token.GrammarSegment == GrammarSegment.Delimiter)
{
_attributeOperator = token.ToString();
}
else
{
_selectorOperation = SelectorOperation.AttributeEnd;
}
}
private void ParseAttribute(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
_selectorOperation = SelectorOperation.AttributeOperator;
switch (token.GrammarSegment)
{
case GrammarSegment.Ident:
_attributeName = ((SymbolBlock)token).Value;
break;
case GrammarSegment.String:
_attributeName = ((StringBlock)token).Value;
break;
default:
_selectorOperation = SelectorOperation.Data;
break;
}
}
private void PrasePseudoClassFunctionEnd(Block token)
{
_selectorOperation = SelectorOperation.Data;
if (token.GrammarSegment != GrammarSegment.ParenClose)
{
return;
}
switch (_attributeName)
{
case PseudoSelectorPrefix.PseudoFunctionNthchild:
Insert(GetChildSelector(PseudoTypes.FunctionNthchild));
break;
case PseudoSelectorPrefix.PseudoFunctionNthlastchild:
Insert(GetChildSelector(PseudoTypes.FunctionNthlastchild));
break;
case PseudoSelectorPrefix.PseudoFunctionNthOfType:
Insert(GetChildSelector(PseudoTypes.FunctionNthOfType));
break;
case PseudoSelectorPrefix.PseudoFunctionNthLastOfType:
Insert(GetChildSelector(PseudoTypes.FunctionNthLastOfType));
break;
case PseudoSelectorPrefix.PseudoFunctionNot:
{
var selector = _nestedSelectorFactory.GetSelector();
Insert(new PseudoFunction(PseudoTypes.FunctionNot) { Body = selector });
break;
}
case PseudoSelectorPrefix.PseudoFunctionDir:
{
Insert(new PseudoFunction(PseudoTypes.FunctionDir) { Body = _attributeValue });
break;
}
case PseudoSelectorPrefix.PseudoFunctionLang:
{
Insert(new PseudoFunction(PseudoTypes.FunctionLang) { Body = _attributeValue });
break;
}
case PseudoSelectorPrefix.PseudoFunctionContains:
{
Insert(new PseudoFunction(PseudoTypes.FunctionContains) { Body = _attributeValue });
break;
}
}
}
private void ParsePseudoClassFunction(Block token)
{
if (token.GrammarSegment == GrammarSegment.Whitespace)
{
return;
}
switch (_attributeName)
{
case PseudoSelectorPrefix.PseudoFunctionNthchild:
case PseudoSelectorPrefix.PseudoFunctionNthlastchild:
case PseudoSelectorPrefix.PseudoFunctionNthOfType:
case PseudoSelectorPrefix.PseudoFunctionNthLastOfType:
{
switch (token.GrammarSegment)
{
case GrammarSegment.Ident:
case GrammarSegment.Number:
case GrammarSegment.Dimension:
_attributeValue += token.ToString();
return;
case GrammarSegment.Delimiter:
var chr = ((DelimiterBlock)token).Value;
if (chr == Specification.PlusSign || chr == Specification.MinusSign)
{
_attributeValue += chr;
return;
}
break;
}
break;
}
case PseudoSelectorPrefix.PseudoFunctionNot:
{
if (_nestedSelectorFactory == null)
{
_nestedSelectorFactory = new SelectorFactory();
}
if (token.GrammarSegment != GrammarSegment.ParenClose || _nestedSelectorFactory._selectorOperation != SelectorOperation.Data)
{
_nestedSelectorFactory.Apply(token);
return;
}
break;
}
case PseudoSelectorPrefix.PseudoFunctionDir:
{
if (token.GrammarSegment == GrammarSegment.Ident)
{
_attributeValue = ((SymbolBlock)token).Value;
}
_selectorOperation = SelectorOperation.PseudoClassFunctionEnd;
return;
}
case PseudoSelectorPrefix.PseudoFunctionLang:
{
if (token.GrammarSegment == GrammarSegment.Ident)
{
_attributeValue = ((SymbolBlock)token).Value;
}
_selectorOperation = SelectorOperation.PseudoClassFunctionEnd;
return;
}
case PseudoSelectorPrefix.PseudoFunctionContains:
{
switch (token.GrammarSegment)
{
case GrammarSegment.String:
_attributeValue = ((StringBlock)token).Value;
break;
case GrammarSegment.Ident:
_attributeValue = ((SymbolBlock)token).Value;
break;
}
_selectorOperation = SelectorOperation.PseudoClassFunctionEnd;
return;
}
}
PrasePseudoClassFunctionEnd(token);
}
internal SelectorFactory ResetFactory()
{
_attributeName = null;
_attributeValue = null;
_attributeOperator = string.Empty;
_selectorOperation = SelectorOperation.Data;
_combinator = Combinator.Descendent;
_hasCombinator = false;
_currentSelector = null;
_aggregateSelectorList = null;
_complexSelector = null;
return this;
}
