public IReadOnlyCollection <ValidationResult> Validate(Token token, ITokenCollection tokenCollection)
{
var value = tokenCollection.Peek();
if (value is null)
{
var error = new ParserError($"{token.Name} value is supposed to be string or array.", token.Line, token.Column);
return(new[] { ValidationResult.Error(error) });
}
if (value.Name == TokenName.StartArray)
{
var result = _stringArrayWithUniqueValuesValidator.Validate(token, tokenCollection, _arrayFilterers);
return(new[] { result });
}
else if (value.Name == TokenName.String)
{
value = tokenCollection.TakeToken();
if (!_typeElementSpecification.IsSatisfied(value))
{
var error = new ParserError($"{token.Name} had invalid value.", token.Line, token.Column);
return(new[] { ValidationResult.Error(error) });
}
}
else
{
var error = new ParserError("Inalid type value.", token.Line, token.Column);
return(new[] { ValidationResult.Error(error) });
}
return(new[] { ValidationResult.Success() });
}
public IReadOnlyCollection <ValidationResult> Validate(Token token, ITokenCollection tokenCollection)
{
var valueToken = tokenCollection.TakeToken();
if (valueToken is null || valueToken.Name != TokenName.String || !valueToken.Value.Any() || Fragment.Empty.Value == valueToken.Value)
{
var parserError = new ParserError("Id value is supposed to be string and cannot be empty", valueToken.Line, valueToken.Column);
return(new[] { ValidationResult.Error(parserError) });
}
return(new[] { ValidationResult.Success() });
}
public IReadOnlyCollection <ValidationResult> Validate(Token token, ITokenCollection tokenCollection)
{
var value = tokenCollection.TakeToken();
if (value is null || value.Name != TokenName.String)
{
var error = new ParserError("Value is supposed to be string.", value.Line, value.Column);
return(new[] { ValidationResult.Error(error) });
}
return(new[] { ValidationResult.Success() });
}
public IReadOnlyCollection <ValidationResult> Validate(Token token, ITokenCollection tokenCollection)
{
var value = tokenCollection.TakeToken();
if (value is null || value.Name != TokenName.Number)
{
var error = new ParserError("Should be number.", token.Line, token.Column);
return(new[] { ValidationResult.Error(error) });
}
return(new[] { ValidationResult.Success() });
}
public IReadOnlyCollection <Token> GetElementTokens(ITokenCollection tokenCollection)
{
var result = new List <Token>();
Token possibleTokenToAdd, possibleTerminatorToken;
do
{
possibleTokenToAdd = tokenCollection.TakeToken();
possibleTerminatorToken = tokenCollection.TakeToken();
if (possibleTerminatorToken is null || possibleTokenToAdd is null)
{
throw new ArrayEndMissingException();
}
if (possibleTokenToAdd.Name != TokenName.Comma)
{
result.Add(possibleTokenToAdd);
}
if (possibleTerminatorToken.Name != TokenName.Comma && possibleTerminatorToken.Name != TokenName.EndArray)
{
throw new ArrayElementSeparatorException();
}
} while (possibleTerminatorToken.Name != TokenName.EndArray);
return(result);
}
public ValidationResult Validate(Token token, ITokenCollection tokenCollection, IEnumerable <IArrayFilterer> filterers)
{
var startArrayToken = tokenCollection.TakeToken();
if (startArrayToken.Name != TokenName.StartArray)
{
return(Error(token, $"{token.Name} value is supposed to be an array."));
}
IReadOnlyCollection <Token> elementTokens;
try
{
elementTokens = _elementExtractor.GetElementTokens(tokenCollection);
}
catch (ArrayEndMissingException e)
{
return(Error(token, e.Message));
}
foreach (var filterer in filterers)
{
try
{
var result = filterer.GetInvalidTokens(elementTokens);
if (result.Any())
{
return(Error(token, filterer.Message));
}
}
catch (Exception e)
{
return(Error(token, e.Message));
}
}
return(ValidationResult.Success());
}
public IReadOnlyCollection <ValidationResult> Validate(Token token, ITokenCollection tokenCollection)
{
var errors = new List <ValidationResult>();
var startObjectToken = tokenCollection.TakeToken();
if (startObjectToken?.Name != TokenName.StartObject)
{
return new[] { Error("Object is supposed to start with '{'.", startObjectToken) }
}
;
var fieldToken = tokenCollection.TakeToken();
while (fieldToken.Name != TokenName.EndObject)
{
var colonToken = tokenCollection.TakeToken();
if (fieldToken is null)
{
errors.Add(Error($"{token.Name} does not have closing curly bracket.", token));
return(errors);
}
if (colonToken is null || colonToken.Name != TokenName.Colon)
{
return(new[] { Error("Object field is supposed have colon after identifier", colonToken) });
}
if (fieldToken.Name != TokenName.String && !_keywords.Contains(fieldToken.Name))
{
return(new[] { Error("Inorrect token. It is supposed to be string", token) });
}
var valueToken = tokenCollection.Peek();
if (_keywords.Contains(fieldToken.Name) && _tokenHandlerFactory.GetTokenValidator(fieldToken) != null)
{
var validator = _tokenHandlerFactory.GetTokenValidator(fieldToken);
var result = validator.Validate(valueToken, tokenCollection);
errors.AddRange(result);
}
else if (valueToken.Name == TokenName.StartArray)
{
var result = _arrayValidator.Validate(valueToken, tokenCollection, Enumerable.Empty <IArrayFilterer>());
errors.Add(result);
}
else if (valueToken.Name == TokenName.StartObject)
{
var result = Validate(valueToken, tokenCollection);
errors.AddRange(result);
}
else
{
var validator = _tokenHandlerFactory.GetTokenValidator(valueToken);
var result = validator.Validate(valueToken, tokenCollection);
errors.AddRange(result);
}
var terminationToken = tokenCollection.Peek();
if (terminationToken is null || (terminationToken.Name != TokenName.Comma && terminationToken.Name != TokenName.EndObject))
{
errors.Add(Error($"Expected comma or end of object.", valueToken));
return(errors);
}
if (terminationToken.Name == TokenName.Comma)
{
tokenCollection.TakeToken();
}
fieldToken = tokenCollection.TakeToken();
}
return(errors);
}
