CssParser
Creates an instance of the CSS parser front-end.
using AngleSharp.Css;
using AngleSharp.Dom.Css;
using AngleSharp.Events;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
namespace AngleSharp.Parser.Css
{
public class CssParser
{
private readonly CssParserOptions _options;
private readonly IConfiguration _config;
internal static readonly CssParser Default = new CssParser();
public CssParserOptions Options => _options;
public IConfiguration Config => _config;
public CssParser()
: this(Configuration.Default)
{
}
public CssParser(CssParserOptions options)
: this(options, Configuration.Default)
{
}
public CssParser(IConfiguration configuration)
: this(default(CssParserOptions), configuration)
{
}
public CssParser(CssParserOptions options, IConfiguration configuration)
{
_options = options;
_config = configuration;
}
public ICssStyleSheet ParseStylesheet(string content)
{
TextSource source = new TextSource(content);
return ParseStylesheet(source);
}
public ICssStyleSheet ParseStylesheet(Stream content)
{
TextSource source = new TextSource(content, null);
return ParseStylesheet(source);
}
public Task<ICssStyleSheet> ParseStylesheetAsync(string content)
{
return ParseStylesheetAsync(content, CancellationToken.None);
}
public async Task<ICssStyleSheet> ParseStylesheetAsync(string content, CancellationToken cancelToken)
{
TextSource source = new TextSource(content);
await source.PrefetchAll(cancelToken).ConfigureAwait(false);
return ParseStylesheet(source);
}
public Task<ICssStyleSheet> ParseStylesheetAsync(Stream content)
{
return ParseStylesheetAsync(content, CancellationToken.None);
}
public async Task<ICssStyleSheet> ParseStylesheetAsync(Stream content, CancellationToken cancelToken)
{
TextSource source = new TextSource(content, null);
await source.PrefetchAll(cancelToken).ConfigureAwait(false);
return ParseStylesheet(source);
}
public ISelector ParseSelector(string selectorText)
{
CssTokenizer cssTokenizer = CreateTokenizer(selectorText, _config);
CssSelectorConstructor cssSelectorConstructor = Pool.NewSelectorConstructor();
CssToken cssToken = cssTokenizer.Get();
while (cssToken.Type != CssTokenType.Eof) {
cssSelectorConstructor.Apply(cssToken);
cssToken = cssTokenizer.Get();
}
bool isValid = cssSelectorConstructor.IsValid;
ISelector result = cssSelectorConstructor.ToPool();
if (!isValid && !_options.IsToleratingInvalidSelectors)
return null;
return result;
}
public IKeyframeSelector ParseKeyframeSelector(string keyText)
{
return Parse(keyText, (CssBuilder b, CssToken t) => Tuple.Create(b.CreateKeyframeSelector(ref t), t));
}
internal ICssStyleSheet ParseStylesheet(TextSource source)
{
CssStyleSheet sheet = new CssStyleSheet(this);
return ParseStylesheet(sheet, source);
}
internal ICssStyleSheet ParseStylesheet(CssStyleSheet sheet, TextSource source)
{
CssTokenizer tokenizer = CreateTokenizer(source, _config);
CssBuilder cssBuilder = new CssBuilder(tokenizer, this);
cssBuilder.CreateRules(sheet);
sheet.ParseTree = cssBuilder.Container;
return sheet;
}
internal CssValue ParseValue(string valueText)
{
CssTokenizer tokenizer = CreateTokenizer(valueText, _config);
CssToken token = null;
CssBuilder cssBuilder = new CssBuilder(tokenizer, this);
CssValue result = cssBuilder.CreateValue(ref token);
if (token.Type != CssTokenType.Eof)
return null;
return result;
}
internal CssRule ParseRule(string ruleText)
{
return Parse(ruleText, (CssBuilder b, CssToken t) => b.CreateRule(t));
}
internal CssProperty ParseDeclaration(string declarationText)
{
return Parse(declarationText, (CssBuilder b, CssToken t) => Tuple.Create(b.CreateDeclaration(ref t), t));
}
internal List<CssMedium> ParseMediaList(string mediaText)
{
return Parse(mediaText, (CssBuilder b, CssToken t) => Tuple.Create(b.CreateMedia(ref t), t));
}
internal CssCondition ParseCondition(string conditionText)
{
return Parse(conditionText, (CssBuilder b, CssToken t) => Tuple.Create(b.CreateCondition(ref t), t));
}
internal List<CssDocumentFunction> ParseDocumentRules(string documentText)
{
return Parse(documentText, (CssBuilder b, CssToken t) => Tuple.Create(b.CreateFunctions(ref t), t));
}
internal CssMedium ParseMedium(string mediumText)
{
return Parse(mediumText, (CssBuilder b, CssToken t) => Tuple.Create(b.CreateMedium(ref t), t));
}
internal CssKeyframeRule ParseKeyframeRule(string ruleText)
{
return Parse(ruleText, (CssBuilder b, CssToken t) => b.CreateKeyframeRule(t));
}
internal void AppendDeclarations(CssStyleDeclaration style, string declarations)
{
CssTokenizer tokenizer = CreateTokenizer(declarations, _config);
CssBuilder cssBuilder = new CssBuilder(tokenizer, this);
cssBuilder.FillDeclarations(style);
}
private T Parse<T>(string source, Func<CssBuilder, CssToken, T> create)
{
CssTokenizer cssTokenizer = CreateTokenizer(source, _config);
CssToken arg = cssTokenizer.Get();
CssBuilder arg2 = new CssBuilder(cssTokenizer, this);
T result = create(arg2, arg);
if (cssTokenizer.Get().Type != CssTokenType.Eof)
return default(T);
return result;
}
private T Parse<T>(string source, Func<CssBuilder, CssToken, Tuple<T, CssToken>> create)
{
CssTokenizer cssTokenizer = CreateTokenizer(source, _config);
CssToken arg = cssTokenizer.Get();
CssBuilder arg2 = new CssBuilder(cssTokenizer, this);
Tuple<T, CssToken> tuple = create(arg2, arg);
if (tuple.Item2.Type != CssTokenType.Eof)
return default(T);
return tuple.Item1;
}
private static CssTokenizer CreateTokenizer(string sourceCode, IConfiguration configuration)
{
TextSource source = new TextSource(sourceCode);
return CreateTokenizer(source, configuration);
}
private static CssTokenizer CreateTokenizer(Stream sourceCode, IConfiguration configuration)
{
TextSource source = new TextSource(sourceCode, null);
return CreateTokenizer(source, configuration);
}
private static CssTokenizer CreateTokenizer(TextSource source, IConfiguration configuration)
{
IEventAggregator events = configuration?.Events;
return new CssTokenizer(source, events);
}
}
}