public void WordStartingWithDataIsNotRegognised()
{
var output = new DataParser().ParseLine(0, " datatest", TokenType.Data).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Parameter, 1, "datatest", Errors.Invalid);
AreEqual(expectedOutput, output);
}
public void DataWithSpacesIsRecognised()
{
var output = new DataParser().ParseLine(0, " data ", TokenType.Data).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Data, 1, "data");
AreEqual(expectedOutput, output);
}
public void SpaceAsWithSpacesIsRecognised()
{
var output = new SpaceAsParser().ParseLine(0, " space as ", TokenType.SpaceAs).Single();
var expected = new ParsedSpan(0, TokenType.SpaceAs, 1, "space as", string.Format(Errors.ExpectsParam, "SpaceAs"));
AreEqual(expected, output);
}
public void TableWithTabIsRecognised()
{
var output = new TableParser().ParseLine(0, " table\t", TokenType.Table).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Table, 1, "table", string.Format(Errors.ExpectsParam, "Table"));
AreEqual(expectedOutput, output);
}
public void CopySqlWithTabIsRecognised()
{
var output = new CopySqlParser().ParseLine(0, "copy sql to\t", TokenType.CopySql).Single();
var expected = new ParsedSpan(0, TokenType.CopySql, 0, "copy sql to", string.Format(Errors.ExpectsParam, "CopySql"));
AreEqual(expected, output);
}
public void TemplateWithTabIsRecognised()
{
var output = new TemplateParser().ParseLine(0, "template\t ", TokenType.Template).Single();
var expected = new ParsedSpan(0, TokenType.Template, 0, "template", string.Format(Errors.ExpectsParam, "Template"));
AreEqual(expected, output);
}
public static void AreEqual(ParsedSpan expected, ParsedSpan test)
{
AreEqual(new List <ParsedSpan> {
expected
}, new List <ParsedSpan> {
test
});
}
public void WordStartingWIthNullAsIsNotRecognised()
{
var output = new NullAsParser().ParseLine(0, " null astest", TokenType.NullAs).Single();
var expected = new ParsedSpan(0, TokenType.Parameter, 1, "null astest", Errors.Invalid);
AreEqual(expected, output);
}
public void WordStartingWithTableIsNotRecognised()
{
var output = new TableParser().ParseLine(0, " tabletest ", TokenType.Table).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Parameter, 2, "tabletest", Errors.Invalid);
AreEqual(expectedOutput, output);
}
public void WordStartingWithSpaceAsIsNotRecognised()
{
var output = new SpaceAsParser().ParseLine(0, "space astest", TokenType.SpaceAs).Single();
var expected = new ParsedSpan(0, TokenType.Parameter, 0, "space astest", Errors.Invalid);
AreEqual(expected, output);
}
public void HeaderRowIsRecognised()
{
var output = new RowParser().ParseLine(0, "|A|B|C|", TokenType.HeaderRow).Single();
var expectedOutput = new ParsedSpan(0, TokenType.HeaderRow, 0, "|A|B|C|");
AreEqual(expectedOutput, output);
}
public void WordStartingWithKeyIsNotRecognised()
{
var output = new KeyParser().ParseLine(0, "keytest", TokenType.Key).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Parameter, 0, "keytest", Errors.Invalid);
AreEqual(expectedOutput, output);
}
public void WordStartingWithEnumIsNotRecognised()
{
var output = new EnumParser().ParseLine(0, " enumtest", TokenType.Enum).Single();
var expected = new ParsedSpan(0, TokenType.Parameter, 1, "enumtest", Errors.Invalid);
AreEqual(expected, output);
}
public void RowLineStarting()
{
var output = new RowParser().ParseLine(0, " |", TokenType.HeaderRow).Single();
var expectedOutput = new ParsedSpan(0, TokenType.HeaderRow, 2, "|");
AreEqual(expectedOutput, output);
}
public void EnumWithTabIsRecognised()
{
var output = new EnumParser().ParseLine(0, " enum\t ", TokenType.Enum).Single();
var expected = new ParsedSpan(0, TokenType.Enum, 1, "enum", string.Format(Errors.ExpectsParam, "Enum"));
AreEqual(expected, output);
}
public void WordStagingWithCopySqlIsNotRecognised()
{
var output = new CopySqlParser().ParseLine(0, "copy sql totest", TokenType.CopySql).Single();
var expected = new ParsedSpan(0, TokenType.Parameter, 0, "copy sql totest", Errors.Invalid);
AreEqual(expected, output);
}
public void ParseCommentLine()
{
var output = new CommentParser().ParseLine(0, " #comment", TokenType.Table).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Comment, 2, "#comment");
AreEqual(expectedOutput, output);
}
public void WordStartingTemplateIsNotRecognised()
{
var output = new TemplateParser().ParseLine(0, "templatetest", TokenType.Template).Single();
var expected = new ParsedSpan(0, TokenType.Parameter, 0, "templatetest", Errors.Invalid);
AreEqual(expected, output);
}
public void ItemRowIsRecognised()
{
var output = new RowParser().ParseLine(0, "|1|2|3|", TokenType.ItemRow).Single();
var expectedOutput = new ParsedSpan(0, TokenType.ItemRow, 0, "|1|2|3|");
AreEqual(expectedOutput, output);
}
public void KeyWithTabIsRecognised()
{
var output = new KeyParser().ParseLine(0, " key\t ", TokenType.Key).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Key, 1, "key", string.Format(Errors.ExpectsParam, "Key"));
AreEqual(expectedOutput, output);
}
public void NullAsWithTabIsRecognised()
{
var output = new NullAsParser().ParseLine(0, " null as\t ", TokenType.NullAs).Single();
var expected = new ParsedSpan(0, TokenType.NullAs, 1, "null as", string.Format(Errors.ExpectsParam, "NullAs"));
AreEqual(expected, output);
}
public override List <ParsedSpan> ParseLine(int lineNumber, string source, TokenType?expectedType)
{
var parsedSpans = new List <ParsedSpan>();
var span = source.GetTextSpan();
var token = TokenType.HeaderRow;
if (expectedType != null && (expectedType & TokenType.HeaderRow) != 0)
{
NextType = TokenType.ItemRow;
}
else
{
token = TokenType.ItemRow;
NextType = TokenType.Data | TokenType.Table | TokenType.ItemRow;
}
var lastPipe = Regex.Matches(span.Text, @"(?<!\\)\|", RegexOptions.Compiled).Cast <Match>().Last().Index + 1;
var data = new ParsedSpan(lineNumber, token, span.To(lastPipe));
CheckKeywordOrder(data, expectedType);
parsedSpans.Add(data);
if (source.Length > lastPipe)
{
var invalidSpan = span.From(lastPipe);
if (invalidSpan.Text.Length > 0)
{
parsedSpans.Add(new ParsedSpan(lineNumber, TokenType.Parameter, invalidSpan, Errors.Invalid));
}
}
if (token == TokenType.ItemRow)
{
return(parsedSpans);
}
var columns = Extensions.Columns.Matches(source);
var duplicates = columns.Cast <Match>()
.GroupBy(a => a.Value.Trim().ToLower())
.SelectMany(a => a.Skip(1))
.ToList();
foreach (var duplicate in duplicates)
{
var value = duplicate.Value.GetTextSpan();
parsedSpans.Add(new ParsedSpan(lineNumber, TokenType.HeaderRow, duplicate.Index + value.Start, value.Text, string.Format(Errors.DuplicateValue, "Column", value.Text)));
}
return(parsedSpans);
}
protected void CheckKeywordOrder(ParsedSpan span, TokenType?expectedType)
{
if ((expectedType & PrimaryType) != 0)
{
NextExpectedToken = NextType;
return;
}
span.Errors.Add(new Error(string.Format(Errors.UnexpectedKeyword, span.Type, expectedType)));
NextExpectedToken = null;
}
public virtual List <ParsedSpan> ParseLine(int lineNumber, string source, TokenType?expectedType)
{
var parsedSpans = new List <ParsedSpan>();
var span = source.GetTextSpan();
if (span.Length > KeywordLength &&
span.Text.Substring(KeywordLength, 1) != " " &&
span.Text.Substring(KeywordLength, 1) != "\t"
)
{
parsedSpans.Add(new ParsedSpan(lineNumber, TokenType.Parameter, span, Errors.Invalid));
return(parsedSpans);
}
var tokenSpan = new ParsedSpan(lineNumber, PrimaryType, span.To(KeywordLength));
parsedSpans.Add(tokenSpan);
if (expectedType != null)
{
CheckKeywordOrder(tokenSpan, expectedType);
}
if (HasParams && span.From(KeywordLength).Length == 0)
{
tokenSpan.Errors.Add(new Error(string.Format(Errors.ExpectsParam, PrimaryType)));
}
if (span.Length > KeywordLength)
{
foreach (ParsedSpan paramToken in GetParamTokens(lineNumber, span.From(KeywordLength)))
{
parsedSpans.Add(paramToken);
}
}
return(parsedSpans);
}
protected override IEnumerable <ParsedSpan> GetParamTokens(int lineNumber, TextSpan span)
{
var parameters = Regex.Matches(span.Text, @"\S+")
.Cast <Match>()
.Select(a => new TextSpan(span.Start + a.Index, a.Value))
.ToList();
var duplicates = parameters
.GroupBy(a => a.Text.ToLower())
.SelectMany(a => a.Skip(1))
.ToList();
foreach (var parameter in parameters)
{
var parsedSpan = new ParsedSpan(lineNumber, TokenType.Key | TokenType.Parameter, parameter);
if (duplicates.Any(a => a.Start == parameter.Start && a.Text == parameter.Text))
{
parsedSpan.Errors.Add(new Error(string.Format(Errors.DuplicateValue, "Key", parameter.Text)));
}
yield return(parsedSpan);
}
}
protected override IEnumerable <ParsedSpan> GetParamTokens(int lineNumber, TextSpan span)
{
var parameters = Regex.Matches(span.Text, @"\S+")
.Cast <Match>()
.Select(a => new TextSpan(a.Index + span.Start, a.Value));
var knownTokens = new Dictionary <TokenType, List <string> >
{
{ TokenType.AccessType, new List <string> {
"public", "internal"
} },
{ TokenType.BaseType, new List <string> {
"byte", "sbyte", "short", "int16", "ushort", "int", "int32", "uint", "long", "int64", "ulong"
} },
{ TokenType.FlagsAttribute, new List <string> {
"flags"
} }
};
var flags = TokenType.AccessType | TokenType.BaseType | TokenType.FlagsAttribute | TokenType.Parameter;
foreach (var parameter in parameters)
{
var found = false;
foreach (var type in knownTokens)
{
if (!type.Value.Contains(parameter.Text, StringComparer.CurrentCultureIgnoreCase))
{
continue;
}
found = true;
var parsedSpan = new ParsedSpan(lineNumber, type.Key, parameter);
if ((flags & type.Key) == 0)
{
parsedSpan.Errors.Add(new Error(string.Format(Errors.EnumDuplicate, type.Key)));
}
else
{
flags ^= type.Key;
}
yield return(parsedSpan);
break;
}
if (found)
{
continue;
}
var paramSpan = new ParsedSpan(lineNumber, TokenType.Enum | TokenType.Parameter, parameter);
if ((flags & TokenType.Parameter) == 0)
{
paramSpan.Errors.Add(new Error(Errors.Invalid));
}
else
{
flags ^= TokenType.Parameter;
}
yield return(paramSpan);
}
}
public void OnEndSpan(ParsedSpan span) {
CodeGenerator.OnEndSpan(span);
}
