public void OptionsLexing2()
{
var spans = Lexer.Lex("$top=2&$orderby=Name&$filter=(Score gt 1000)").ToArray();
Assert.Equal(spans,
new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.ReservedWord, 0, 4),
TokenSpan.Of(Token.Equals, 4, 5),
TokenSpan.Of(Token.Number, 5, 6),
TokenSpan.Of(Token.Ampersand, 6, 7),
TokenSpan.Of(Token.ReservedWord, 7, 15),
TokenSpan.Of(Token.Equals, 15, 16),
TokenSpan.Of(Token.Word, 16, 20),
TokenSpan.Of(Token.Ampersand, 20, 21),
TokenSpan.Of(Token.ReservedWord, 21, 28),
TokenSpan.Of(Token.Equals, 28, 29),
TokenSpan.Of(Token.Open, 29, 30),
TokenSpan.Of(Token.Word, 30, 35),
TokenSpan.Of(Token.Space, 35, 36),
TokenSpan.Of(Token.Word, 36, 38),
TokenSpan.Of(Token.Space, 38, 39),
TokenSpan.Of(Token.Number, 39, 43),
TokenSpan.Of(Token.Close, 43, 44),
TokenSpan.Of(Token.End, 44, 44)
});
}
public Match(TokenSpan span, IExpression value, IReadOnlyList <Case> cases, Else? @else)
{
Span = span;
Value = value;
Cases = cases;
Else = @else;
}
public Unit(TokenSpan span, String?packageDoc, MemberList items)
{
Span = span;
PackageDoc = packageDoc;
Items = items;
Members = new DistinctList <INamed, Class>();
}
public Call(TokenSpan span, IExpression expression, ArgumentList arguments, Throws?throws)
{
Span = span;
Expression = expression;
Arguments = arguments;
Throws = throws;
}
public LambdaParameter(TokenSpan span, Identifier name, IType?type, IExpression?value)
{
Span = span;
Name = name;
Type = type;
Value = value;
}
public TypeParameter(TokenSpan span, Identifier name, IType?type, IType? @default)
{
Span = span;
Name = name;
Type = type;
Default = @default;
}
public NameCapture(TokenSpan span, Identifier name, IType?type, IExpression?value)
{
Span = span;
Name = name;
Type = type;
Value = value;
}
public Case(TokenSpan span, IExpression?pattern, When?when, Body?body)
{
Span = span;
Pattern = pattern;
When = when;
Body = body;
}
public While(TokenSpan span, IExpression condition, IExpression body, Else? @else)
{
Span = span;
Condition = condition;
Body = body;
Else = @else;
}
public If(TokenSpan span, IfKind kind, IReadOnlyList <Conditional> conditionals, Else?elseBody)
{
Span = span;
Kind = kind;
Conditionals = conditionals;
ElseBody = elseBody;
}
public Try(TokenSpan span, IExpression body, Else? @else, Then?then)
{
Span = span;
Body = body;
Else = @else;
Then = then;
}
public Repeat(TokenSpan span, IExpression body, IExpression condition, Else? @else)
{
Span = span;
Body = body;
Condition = condition;
Else = @else;
}
public ValueParameter(TokenSpan span, Identifier name, IType type, IExpression?value)
{
Span = span;
Name = name;
Type = type;
Default = value;
}
private IEnumerable <TToken> TransformBuilders(TToken[] tokens, TokenSpan span, List <MatchInfo> builders, Scope scope)
{
int current = span.Start;
foreach (var builder in builders)
{
if (builder.Span.Start > current)
{
for (int i = current; i < builder.Span.Start; i++)
{
yield return(tokens[i]); //literal
}
current = builder.Span.Start;
}
int consumed;
var matchedTokens = buildMatchResult(tokens, builder, scope, out consumed);
var transformer = builder.Match.Transform;
current += consumed;
Debug.Assert(transformer != null);
var matchTokens = transformer.transform(matchedTokens, builder.Match, scope);
foreach (var matchToken in matchTokens)
{
yield return(matchToken);
}
}
for (int i = current; i < span.Start + span.Length; i++)
{
yield return(tokens[i]); //finish
}
}
public For(TokenSpan span, INamePattern names, IExpression values, IExpression body, Else? @else)
{
Span = span;
Names = names;
Values = values;
Body = body;
Else = @else;
}
public TokenSpan Consume(int count)
{
var result = new TokenSpan(_current, count);
_current += count;
_tokens = _tokens.Skip(count);
return(result);
}
public Local(TokenSpan span, LocalKind kind, Identifier name, IType?type, String?doc)
{
Span = span;
Kind = kind;
Name = name;
Type = type;
Doc = doc;
}
public LambdaType(TokenSpan span, Identifier?name, TypeParameterList?typeParameters, TypeList parameters, IType?result, Throws?throws)
{
Span = span;
Name = name;
TypeParameters = typeParameters;
Parameters = parameters;
Result = result;
Throws = throws;
}
public void Lexes_String_WithPercents() {
var spans = Lexer.Lex($"%27Blah%27").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.String, 0, 10),
TokenSpan.Of(Token.End, 10, 10)
});
}
public void Lexes_GUID() {
var spans = Lexer.Lex($"Aa1234ea-4321-1234-bbBB-AAAA1111cccc").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.Guid, 0, 36),
TokenSpan.Of(Token.End, 36, 36)
});
}
public Field(TokenSpan span, FieldKind kind, Identifier name, IType type, IExpression?init, String?doc)
{
Span = span;
Kind = kind;
Name = name;
Type = type;
Init = init;
Doc = doc;
}
public void Lexes_DateTime() {
var spans = Lexer.Lex($"2012-05-29T09:13:28ZHello").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.Date, 0, 20),
TokenSpan.Of(Token.Word, 20, 25),
TokenSpan.Of(Token.End, 25, 25)
});
}
public void Lexes_Date() {
var spans = Lexer.Lex($"2017-03-01Boo").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.Date, 0, 10),
TokenSpan.Of(Token.Word, 10, 13),
TokenSpan.Of(Token.End, 13, 13)
});
}
public void Lexes_Decimal() {
var spans = Lexer.Lex($"2.89Hello").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.Decimal, 0, 4),
TokenSpan.Of(Token.Word, 4, 9),
TokenSpan.Of(Token.End, 9, 9)
});
}
public Lambda(TokenSpan span, Identifier?name, TypeParameterList?typeParameters, ParameterList parameters, CaptureList?captures, IType?result, Throws?throws, IExpression body)
{
Span = span;
Name = name;
TypeParameters = typeParameters;
Parameters = parameters;
Captures = captures;
Result = result;
Throws = throws;
Body = body;
}
public Method(TokenSpan span, MethodKind kind, Identifier name, TypeParameterList?typeParameters, ParameterList valueParameters, IType? @return, Throws?throws, String?doc, IExpression?body)
{
Span = span;
Kind = kind;
Doc = doc;
Name = name;
TypeParameters = typeParameters;
ValueParameters = valueParameters;
Return = @return;
Throws = throws;
Body = body;
}
public void OptionsLexing_Handles_PercentEncodings1()
{
var spans = Lexer.Lex("(%27Hello%27)").ToArray();
Assert.Equal(spans,
new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.Open, 0, 1),
TokenSpan.Of(Token.String, 1, 12),
TokenSpan.Of(Token.Close, 12, 13),
TokenSpan.Of(Token.End, 13, 13)
});
}
public Class(TokenSpan span, ClassKind kind, Identifier name, TypeParameterList?typeParameters, IType?provides, String?doc, MemberList items)
{
Span = span;
Kind = kind;
Name = name;
TypeParameters = typeParameters;
Provides = provides;
Doc = doc;
Items = items;
Members = new NamedList <INamedMember>();
Fields = new NamedList <Field>();
Methods = new NamedList <Method>();
}
public void ResourcePath_Lexing1()
{
var spans = Lexer.Lex("Dogs/Chihuahuas('Boris')").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.Word, 0, 4),
TokenSpan.Of(Token.Slash, 4, 5),
TokenSpan.Of(Token.Word, 5, 15),
TokenSpan.Of(Token.Open, 15, 16),
TokenSpan.Of(Token.String, 16, 23),
TokenSpan.Of(Token.Close, 23, 24),
TokenSpan.Of(Token.End, 24, 24)
});
}
public void OptionsLexing1()
{
var spans = Lexer.Lex("$filter=name eq 'Boris'").ToArray();
spans.ShouldBe(new[] {
TokenSpan.Of(Token.Start, 0, 0),
TokenSpan.Of(Token.ReservedWord, 0, 7),
TokenSpan.Of(Token.Equals, 7, 8),
TokenSpan.Of(Token.Word, 8, 12),
TokenSpan.Of(Token.Space, 12, 13),
TokenSpan.Of(Token.Word, 13, 15),
TokenSpan.Of(Token.Space, 15, 16),
TokenSpan.Of(Token.String, 16, 23),
TokenSpan.Of(Token.End, 23, 23)
});
}
