public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "extend"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
var selector = itemFactory.CreateSpecific <SelectorGroup>(this, text, stream);
if (selector.Parse(itemFactory, text, stream))
{
Selector = selector;
Children.Add(selector);
}
if (stream.Current.Type == TokenType.Bang)
{
var modifier = new OptionalModifier();
if (modifier.Parse(itemFactory, text, stream))
{
Modifier = modifier;
Children.Add(modifier);
}
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "media"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
while (!IsTerminator(stream.Current.Type))
{
var query = itemFactory.CreateSpecific <MediaQuery>(this, text, stream);
if (query.Parse(itemFactory, text, stream))
{
_Queries.Add(query);
Children.Add(query);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
var block = itemFactory.CreateSpecific <MediaQueryBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "media"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
while (!IsTerminator(stream.Current.Type))
{
var query = itemFactory.CreateSpecific<MediaQuery>(this, text, stream);
if (query.Parse(itemFactory, text, stream))
{
_Queries.Add(query);
Children.Add(query);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
var block = itemFactory.CreateSpecific<MediaQueryBlock>(this, text, stream);
if (block.Parse(itemFactory, text, stream))
{
Body = block;
Children.Add(block);
}
}
return Children.Count > 0;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "each"))
{
ParseRule(itemFactory, text, stream);
while (!IsListTerminator(stream.Current.Type))
{
var item = itemFactory.CreateSpecific <ListItem>(this, text, stream);
if (item != null && item.Parse(itemFactory, text, stream))
{
_Items.Add(item);
Children.Add(item);
}
else
{
// bad news bears
Children.AddCurrentAndAdvance(stream);
}
}
ParseBody(itemFactory, text, stream);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "for"))
{
ParseRule(itemFactory, text, stream);
var variable = new VariableName(SassClassifierType.VariableDefinition);
if (variable.Parse(itemFactory, text, stream))
{
Variable = variable;
Children.Add(Variable);
}
if (IsKeyword(text, stream, "from"))
{
FromKeyword = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
while (!(IsKeyword(text, stream, "to") || IsKeyword(text, stream, "through")))
{
ParseItem fromValue;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out fromValue))
{
FromExpressionValues.Add(fromValue);
Children.Add(fromValue);
}
}
}
bool isToKeyword = IsKeyword(text, stream, "to");
bool isThroughKeyword = !isToKeyword && IsKeyword(text, stream, "through");
if (isToKeyword || isThroughKeyword)
{
if (isToKeyword)
{
ToKeyword = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
if (isThroughKeyword)
{
ThroughKeyword = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword);
}
while (!IsRangeTerminator(stream.Current.Type))
{
ParseItem rangeValue;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out rangeValue))
{
RangeExpressionValues.Add(rangeValue);
Children.Add(rangeValue);
}
}
}
ParseBody(itemFactory, text, stream);
}
return(Children.Count > 0);
}
public static AtRule CreateParsed(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var rule = new AtRule();
if (rule.Parse(itemFactory, text, stream))
return rule;
return null;
}
public virtual bool ParseRule(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
return Rule != null;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "include"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
Name = MixinName.CreateParsed(itemFactory, text, stream, SassClassifierType.MixinReference);
if (Name != null)
{
Children.Add(Name);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
while (!IsTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific <FunctionArgument>(this, text, stream);
if (argument != null && argument.Parse(itemFactory, text, stream))
{
_Arguments.Add(argument);
Children.Add(argument);
}
else
{
Children.AddCurrentAndAdvance(stream);
}
}
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
{
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream);
}
else if (stream.Current.Type == TokenType.OpenCurlyBrace)
{
var content = new MixinContentBlock();
if (content.Parse(itemFactory, text, stream))
{
Content = content;
Children.Add(content);
}
}
}
return(Children.Count > 0);
}
public virtual bool ParseRule(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
return(Rule != null);
}
public static AtRule CreateParsed(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
var rule = new AtRule();
if (rule.Parse(itemFactory, text, stream))
{
return(rule);
}
return(null);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "function"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
if (stream.Current.Type == TokenType.Function)
{
Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.UserFunctionDefinition);
FunctionName = text.GetText(Name.Start, Name.Length);
}
if (stream.Current.Type == TokenType.OpenFunctionBrace)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
while (!IsArgumentTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific <FunctionArgumentDefinition>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
{
break;
}
Arguments.Add(argument);
Children.Add(argument);
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
{
Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
}
var body = new UserFunctionBody();
if (body.Parse(itemFactory, text, stream))
{
Body = body;
Children.Add(body);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, RuleName))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
ParseDirective(itemFactory, text, stream);
ParseBlock(itemFactory, text, stream);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "content"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
{
Children.Add(Rule);
}
if (stream.Current.Type == TokenType.Semicolon)
{
Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
}
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "while"))
{
ParseRule(itemFactory, text, stream);
while (!IsConditionTerminator(stream.Current.Type))
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Children.Add(item);
}
}
ParseBody(itemFactory, text, stream);
}
return(Children.Count > 0);
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
if (AtRule.IsRule(text, stream, "mixin"))
{
Rule = AtRule.CreateParsed(itemFactory, text, stream);
if (Rule != null)
Children.Add(Rule);
Name = MixinName.CreateParsed(itemFactory, text, stream, SassClassifierType.MixinDefinition);
if (Name != null)
Children.Add(Name);
if (stream.Current.Type == TokenType.OpenFunctionBrace)
OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
while (!IsArgumentTerminator(stream.Current.Type))
{
var argument = itemFactory.CreateSpecific<FunctionArgumentDefinition>(this, text, stream);
if (argument == null || !argument.Parse(itemFactory, text, stream))
break;
_Arguments.Add(argument);
Children.Add(argument);
}
if (stream.Current.Type == TokenType.CloseFunctionBrace)
CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);
var body = new MixinDefinitionBody();
if (body.Parse(itemFactory, text, stream))
{
Body = body;
Children.Add(body);
}
}
return Children.Count > 0;
}
