public override void WriteOutput(OutputContext context)
{
if (Block.RuleCount == 0)
{
return;
}
if (context.IsReference)
{
var extenderSelectorList = new SelectorList(Selectors.Selectors.SelectMany(s => context.Extensions.GetExtensions(s, includeReferences: false)));
if (extenderSelectorList.IsEmpty())
{
return;
}
context.Append(extenderSelectorList);
}
else
{
context.Append(Selectors);
}
context.AppendOptional(' ');
context.AppendLine("{");
context.Append(Block);
context.Indent();
context.AppendLine("}");
}
public SelectorList RemovePrefixes(SelectorList other)
{
IEnumerable <Selector> GetResultingSelectors()
{
foreach (var selector in Selectors)
{
foreach (var otherSelector in other.Selectors)
{
var resultingPrefix = selector.RemovePrefix(otherSelector);
if (resultingPrefix != null)
{
yield return(resultingPrefix);
}
}
}
}
return(new SelectorList(GetResultingSelectors()));
}
public SelectorList Inherit(SelectorList parent)
{
IEnumerable <Selector> InheritSelectors()
{
foreach (var selector in selectors)
{
foreach (var generatedSelector in selector.Inherit(parent))
{
yield return(generatedSelector);
}
}
}
if (parent.IsEmpty())
{
return(this);
}
return(new SelectorList(InheritSelectors()));
}
public IEnumerable <Selector> Inherit(SelectorList parentSelectors)
{
IEnumerable <SelectorElement> SubstituteFirstParentSelector(Selector parentSelector,
IReadOnlyList <SelectorElement> currentElements,
int firstIndex)
{
bool substituted = false;
int current = -1;
foreach (var selectorElement in currentElements)
{
current += 1;
if (current >= firstIndex && !substituted && selectorElement is ParentReferenceSelectorElement parentRef)
{
// Add all parent selector elements except the last one
for (int i = 0; i < parentSelector.Elements.Count - 1; i++)
{
yield return(parentSelector.Elements[i]);
}
var lastParentElement = parentSelector.Elements.LastOrDefault();
if (lastParentElement != null)
{
yield return(lastParentElement.Clone(parentRef.HasTrailingWhitespace));
}
substituted = true;
}
else
{
yield return(selectorElement);
}
}
}
IEnumerable <Selector> SubstituteParentReferences(IReadOnlyList <SelectorElement> currentElements, bool isRoot = false, int?startFrom = null)
{
int firstIndex = currentElements.FirstIndexOf <ParentReferenceSelectorElement>(startFrom ?? 0);
if (firstIndex > -1)
{
foreach (var selector in parentSelectors.Selectors)
{
var substituted = SubstituteFirstParentSelector(selector, currentElements, firstIndex).ToList();
foreach (var generatedSelector in SubstituteParentReferences(substituted, false, firstIndex + selector.Elements.Count))
{
yield return(generatedSelector);
}
}
}
else if (isRoot)
{
foreach (var parentSelector in parentSelectors.Selectors)
{
yield return(parentSelector.Append(currentElements));
}
}
else
{
yield return(new Selector(currentElements, Extend));
}
}
return(SubstituteParentReferences(Elements, true));
}
public Ruleset(SelectorList selectors, RuleBlock block)
{
this.Selectors = selectors;
Guard = null;
this.Block = block;
}
public Ruleset(SelectorList selectors, RulesetGuard guard, RuleBlock block)
{
this.Selectors = selectors;
Guard = guard;
this.Block = block;
}
protected bool Equals(SelectorList other)
{
return(selectors.SequenceEqual(other.selectors));
}
public bool MatchesAny(SelectorList selectorList)
{
return(Selectors.Any(s => selectorList.Selectors.Any(s.Matches)));
}
