public MainWindow()
{
InitializeComponent();
var xshdAsString = ManifestResource.Load("RavenQuery.SyntaxTester.RQLSyntaxHighlighting.xshd");
using (var reader = new XmlTextReader(new StringReader(xshdAsString)))
{
var editorSyntaxHighlighting = HighlightingLoader.Load(reader, HighlightingManager.Instance);
HighlightingManager.Instance.RegisterHighlighting("RQL", new[] { ".rql" }, editorSyntaxHighlighting);
}
CodeEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("RQL");
_lexer = new QueryLexer(null);
_parser = new QueryParser(null);
_errorStrategy = new UserFriendlyErrorStrategy();
_parser.ErrorHandler = _errorStrategy;
_parser.AddErrorListener(_errorListener);
Observable.FromEventPattern(
ev => CodeEditor.TextChanged += ev,
ev => CodeEditor.TextChanged -= ev)
.Throttle(TimeSpan.FromMilliseconds(750))
.Subscribe(_ => Dispatcher.InvokeAsync(ParseRQL));
InitializeTextMarkerService();
}
internal IExecutableQuery Compile(
TextReader inputQuery,
IQueryErrorListener queryErrorListener,
QueryCompilationParameters parameters)
{
// create all necessary components to parse a query
var input = new AntlrInputStream(inputQuery);
var lexer = new QueryLexer(input);
lexer.AddErrorListener(new LexerErrorListener(queryErrorListener));
var compiler = new QueryCompilationListener(
_queryFactory,
this,
queryErrorListener,
_runtime,
parameters);
var tokenStream = new CommonTokenStream(lexer);
var errorListener = new ParserErrorListener(queryErrorListener);
var parser = new QueryParser(tokenStream);
parser.AddErrorListener(errorListener);
// parse and compile the query
if (!parameters.IsRecursiveCall)
{
queryErrorListener.BeforeCompilation();
}
IQuery result;
try
{
var tree = parser.entry();
ParseTreeWalker.Default.Walk(compiler, tree);
result = compiler.Finish();
if (result == null)
{
return(null);
}
result = result.WithText(input.ToString());
}
catch (ParseCanceledException)
{
// an error has already been reported
return(null);
}
finally
{
if (!parameters.IsRecursiveCall)
{
queryErrorListener.AfterCompilation();
}
}
return(result);
}
public void Should_throw_if_missing_function_definition()
{
var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("declare function"))));
parser.AddErrorListener(_errorListener);
var ast = parser.projectionFunctionClause();
Assert.Single(_errorListener.Errors);
Assert.Contains("function definition", _errorListener.Errors[0].Message);
}
public void Should_throw_if_missing_opening_paren()
{
var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("declare function foo a,b) { return a + b; }"))));
parser.AddErrorListener(_errorListener);
var ast = parser.projectionFunctionClause();
Assert.Single(_errorListener.Errors);
Assert.Contains('(', _errorListener.Errors[0].Message);
}
public void Should_throw_twice_if_missing_two_commas()
{
var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("declare function foo (a b c) { return a + b; }"))));
parser.AddErrorListener(_errorListener);
parser.projectionFunctionClause();
Assert.Equal(2, _errorListener.Errors.Count);
Assert.Contains(',', _errorListener.Errors[0].Message);
Assert.Contains(',', _errorListener.Errors[1].Message);
}
public void Should_throw_on_load_missing_as_keyword()
{
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("load foo x"))));
parser.AddErrorListener(_errorListener);
parser.loadClause();
Assert.Single(_errorListener.Errors);
Assert.Contains("'as'", _errorListener.Errors[0].Message);
}
public void Should_throw_on_load_missing_identifier()
{
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("load as x"))));
parser.AddErrorListener(_errorListener);
parser.loadClause();
Assert.Single(_errorListener.Errors);
Assert.Contains("document id", _errorListener.Errors[0].Message);
}
public void Should_throw_if_missing_curly_end()
{
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("declare function foo(a,b) return a + b; }"))));
parser.AddErrorListener(_errorListener);
parser.projectionFunctionClause();
Assert.NotEmpty(_errorListener.Errors);
Assert.Contains('{', _errorListener.Errors[0].Message);
}
public void Should_throw_on_load_missing_comma()
{
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("load as x bar as y"))));
parser.AddErrorListener(_errorListener);
parser.loadClause();
Assert.Equal(2, _errorListener.Errors.Count);
Assert.Contains("document id", _errorListener.Errors[0].Message);
Assert.Contains("','", _errorListener.Errors[1].Message);
}
public void Should_throw_on_load_without_identifiers()
{
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("load"))));
parser.AddErrorListener(_errorListener);
var loadAst = parser.loadClause();
Assert.Single(_errorListener.Errors);
Assert.Contains("one or more document id(s)", _errorListener.Errors[0].Message);
}
public void Throw_error_on_missing_right_bracket_all_in_expression()
{
//conditionExpression
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("x all in (0,2,4"))));
parser.AddErrorListener(_errorListener);
parser.conditionExpression();
Assert.Single(_errorListener.Errors);
Assert.Contains("')'", _errorListener.Errors[0].Message);
}
public void Throw_error_on_missing_and_in_between_expression()
{
//conditionExpression
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("x between 1 4"))));
parser.AddErrorListener(_errorListener);
parser.conditionExpression();
Assert.Single(_errorListener.Errors);
Assert.Contains("'and'", _errorListener.Errors[0].Message);
}
public void Error_on_empty_from_query()
{
var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from"))));
parser.AddErrorListener(_errorListener);
parser.query();
Assert.Single(_errorListener.Errors);
Assert.Contains("index or collection name", _errorListener.Errors[0].Message);
_errorListener = new SyntaxErrorListener();
parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from foobar"))));
parser.query();
Assert.Empty(_errorListener.Errors);
}
public static QueryParser.ProgramContext Parse(string query)
{
var lexer = new QueryLexer(new AntlrInputStream(query));
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new ThrowingErrorListener <int>());
var parser = new QueryParser(new CommonTokenStream(lexer));
parser.RemoveErrorListeners();
parser.AddErrorListener(new ThrowingErrorListener <IToken>());
return(parser.program());
}
public void Error_on_missing_index_name()
{
var parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from index"))));
parser.AddErrorListener(_errorListener);
parser.query();
Assert.Single(_errorListener.Errors);
Assert.Contains("index name", _errorListener.Errors[0].Message);
_errorListener = new SyntaxErrorListener();
parser = new QueryParser(new CommonTokenStream(new QueryLexer(new AntlrInputStream("from index 'foo/bar'"))));
parser.AddErrorListener(_errorListener);
parser.query();
Assert.Empty(_errorListener.Errors);
}
public void Should_parse_load_clause()
{
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("load foo as x, bar as y"))));
parser.AddErrorListener(_errorListener);
var loadAst = parser.loadClause();
Assert.Empty(_errorListener.Errors);
var identifiers = loadAst._params.Select(x => x.identifier.GetText()).ToList();
Assert.Contains("foo", identifiers);
Assert.Contains("bar", identifiers);
var aliases = loadAst._params.Select(x => x.aliasClause().alias.Text).ToList();
Assert.Contains("x", aliases);
Assert.Contains("y", aliases);
}
public void Can_parse_transform_function()
{
var parser = new QueryParser(
new CommonTokenStream(
new QueryLexer(
new AntlrInputStream("declare function foo(a,b) { return a + b; }"))));
parser.AddErrorListener(_errorListener);
var ast = parser.projectionFunctionClause();
Assert.Empty(_errorListener.Errors);
Assert.Equal("foo", ast.functionName.Text);
Assert.True(ast.javascriptBlock().sourceCode.TryGetChild <QueryParser.ReturnStatementContext>(out _));
Assert.True(ast.javascriptBlock().TryGetChild <QueryParser.JavascriptAdditiveExpressionContext>(out var returnedExpression));
var identifiers = returnedExpression.GetAllChildrenOfType <QueryParser.JavascriptIdentifierExpressionContext>().ToList();
Assert.Equal(2, identifiers.Count);
Assert.Equal("a", identifiers[0].GetText());
Assert.Equal("b", identifiers[1].GetText());
}
public void Can_parse_between_expression()
{
//conditionExpression
var parser =
new QueryParser(
new CommonTokenStream(
new QueryLexer(new AntlrInputStream("x between 0 and 5"))));
parser.AddErrorListener(_errorListener);
var ast = parser.conditionExpression();
Assert.Empty(_errorListener.Errors);
Assert.True(ast.TryGetChild <QueryParser.QueryIdentifierExpressionContext>(out var identifierContext));
Assert.Equal("x", identifierContext.GetText());
var literals = ast.GetAllChildrenOfType <QueryParser.QueryLiteralContext>().Select(x => x.GetText()).ToArray();
Assert.Equal(2, literals.Length);
Assert.Contains("0", literals);
Assert.Contains("5", literals);
}
