public void TextWithStartingQuote_TryMatchTextWithNoQuote_Matches()
{
var options = new[] { "abc", "xyz" };
var match = ArrayRunEnumSegment.TryMatch("\"ab", options, out int _);
Assert.True(match);
}
public void SingleQuote_TryMatch_NoMatch()
{
var options = new[] { "abc", "xyz" };
var match = ArrayRunEnumSegment.TryMatch("\"", options, out int _);
Assert.False(match);
}
private IEnumerable <AutocompleteItem> GetAutocompleteMoveOptions(string line, int caretIndex)
{
var namePart = line.Split("-")[1].Trim();
return(ArrayRunEnumSegment.GetOptions(model, HardcodeTablesModel.MoveNamesTable)
.Where(option => option.MatchesPartial(namePart, onlyCheckLettersAndDigits: true))
.Select(option => new AutocompleteItem(option, $"- {option}")));
}
public override bool Write(IDataModel model, ModelDelta token, int start, ref string data)
{
var parts = data.Split(new[] { "(", ")", " " }, StringSplitOptions.RemoveEmptyEntries).ToList();
TableStreamRun.Recombine(parts, "\"", "\"");
data = string.Empty;
if (parts.Count != VisibleElementCount)
{
return(false);
}
int bitOffset = 0;
int partIndex = 0;
bool anyChanges = false;
for (int i = 0; i < Elements.Count; i++)
{
if (string.IsNullOrEmpty(Elements[i].Name))
{
// Unnamed segments. I should increment, and bitOffset should increase, but the value should change to zero.
anyChanges |= Elements[i].Write(model, token, start, bitOffset, 0);
partIndex -= 1;
}
else if (!string.IsNullOrEmpty(Elements[i].SourceName))
{
if (ArrayRunEnumSegment.TryParse(Elements[i].SourceName, model, parts[partIndex], out int value))
{
anyChanges |= Elements[i].Write(model, token, start, bitOffset, value);
}
}
else if (Elements[i].BitWidth == 1)
{
if (bool.TryParse(parts[partIndex], out bool value))
{
anyChanges |= Elements[i].Write(model, token, start, bitOffset, value ? 1 : 0);
}
}
else
{
if (int.TryParse(parts[partIndex], out int value))
{
anyChanges |= Elements[i].Write(model, token, start, bitOffset, value);
}
}
partIndex += 1;
bitOffset += Elements[i].BitWidth;
}
var remainingBits = Length * 8 - bitOffset;
if (remainingBits > 0)
{
anyChanges |= new TupleSegment(string.Empty, remainingBits).Write(model, token, start, bitOffset, 0);
}
return(anyChanges);
}
public ModelArrayElement this[string value] {
get {
var table = model.GetNextRun(arrayAddress) as ITableRun;
if (ArrayRunEnumSegment.TryMatch(value, table.ElementNames, out int index))
{
return(this[index]);
}
else
{
throw new NotImplementedException();
}
}
}
private IEnumerable <AutocompleteItem> GetAutocompletePokemonOptions(string line, int caretIndex)
{
var result = new List <AutocompleteItem>();
var end = line.Substring(caretIndex).Trim();
var start = line.Substring(0, caretIndex).Trim();
var spaceIndex = start.IndexOf(" ");
var parenIndex = start.IndexOf("(");
var endParenIndex = start.IndexOf(")");
var atIndex = start.IndexOf("@");
// level
if (spaceIndex == -1)
{
return(result);
}
// pokemon
if (parenIndex == -1 && atIndex == -1)
{
var level = start.Substring(0, spaceIndex);
var pokemon = start.Substring(spaceIndex + 1);
return(ArrayRunEnumSegment.GetOptions(model, HardcodeTablesModel.PokemonNameTable)
.Where(option => option.MatchesPartial(pokemon, onlyCheckLettersAndDigits: true))
.Where(option => option.Contains("-") || !pokemon.Contains("-"))
.Where(option => option.Contains("'") || !pokemon.Contains("'"))
.Where(option => option.Contains(".") || !pokemon.Contains("."))
.Select(option => new AutocompleteItem(option, $"{level} {option} {end}")));
}
// IVs
if (parenIndex >= 0 && endParenIndex == -1)
{
return(result);
}
// Item
if (atIndex == -1)
{
return(result);
}
var item = start.Substring(atIndex + 1);
start = start.Substring(0, atIndex);
var options = ArrayRunEnumSegment.GetOptions(model, HardcodeTablesModel.ItemsTableName).ToList();
return(options
.Where(option => option.MatchesPartial(item, onlyCheckLettersAndDigits: true))
.Where(option => option.Contains("-") || !item.Contains("-"))
.Where(option => option.Contains("'") || !item.Contains("'"))
.Select(option => new AutocompleteItem(option, $"{start.Trim()} @{option}")));
}
public int Convert(IDataModel model, string value)
{
int result;
if (string.IsNullOrEmpty(EnumTableName))
{
if (int.TryParse(value, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out result))
{
return(result);
}
return(0);
}
if (ArrayRunEnumSegment.TryParse(EnumTableName, model, value, out result))
{
return(result);
}
return(0);
}
public IReadOnlyList <AutocompleteItem> GetAutocomplete(IDataModel model, string text)
{
var tupleTokens = text.Split(" ").ToList();
TableStreamRun.Recombine(tupleTokens, "\"", "\"");
if (tupleTokens[0].StartsWith("("))
{
tupleTokens[0] = tupleTokens[0].Substring(1);
}
var visibleTupleElements = Elements.Where(element => !string.IsNullOrEmpty(element.Name)).ToList();
var optionToken = tupleTokens.Last();
tupleTokens = tupleTokens.Take(tupleTokens.Count - 1).ToList();
if (visibleTupleElements.Count > tupleTokens.Count)
{
var tupleToken = visibleTupleElements[tupleTokens.Count];
if (optionToken.StartsWith("\""))
{
optionToken = optionToken.Substring(1);
}
if (optionToken.EndsWith("\""))
{
optionToken = optionToken.Substring(0, optionToken.Length - 1);
}
if (!string.IsNullOrEmpty(tupleToken.SourceName))
{
var optionText = ArrayRunEnumSegment.GetOptions(model, tupleToken.SourceName).Where(option => option.MatchesPartial(optionToken));
return(CreateTupleEnumAutocompleteOptions(tupleTokens, optionText));
}
else if (tupleToken.BitWidth == 1)
{
var optionText = new[] { "false", "true" }.Where(option => option.MatchesPartial(optionToken));
return(CreateTupleEnumAutocompleteOptions(tupleTokens, optionText));
}
}
return(null);
}
private IReadOnlyList <AutocompleteItem> GetAutoCompleteOptionsForSingleElementStream(string line, int caretIndex)
{
var results = new List <AutocompleteItem>();
var lineStart = line.Substring(0, caretIndex);
var lineEnd = line.Substring(caretIndex);
if (lineStart.Count(':') != 1)
{
return(results);
}
var fieldName = lineStart.Split(':')[0].Trim();
var currentContent = lineStart.Split(':')[1].Trim();
var field = ElementContent.Where(segment => segment.Name == fieldName).FirstOrDefault();
if (field == null)
{
return(null);
}
if (field is ArrayRunEnumSegment enumSegment)
{
var optionText = enumSegment.GetOptions(model).Where(option => option.MatchesPartial(currentContent));
results.AddRange(CreateSingleElementEnumAutocompleteOptions(lineEnd, fieldName, optionText));
}
else if (field is ArrayRunTupleSegment tupleGroup)
{
var tupleTokens = currentContent.Split(" ").ToList();
Recombine(tupleTokens, "\"", "\"");
if (tupleTokens[0].StartsWith("("))
{
tupleTokens[0] = tupleTokens[0].Substring(1);
}
var visibleTupleElements = tupleGroup.Elements.Where(element => !string.IsNullOrEmpty(element.Name)).ToList();
if (visibleTupleElements.Count >= tupleTokens.Count)
{
var tupleToken = visibleTupleElements[tupleTokens.Count - 1];
var optionToken = tupleTokens.Last();
if (optionToken.StartsWith("\""))
{
optionToken = optionToken.Substring(1);
}
if (optionToken.EndsWith("\""))
{
optionToken = optionToken.Substring(0, optionToken.Length - 1);
}
tupleTokens = tupleTokens.Take(tupleTokens.Count - 1).ToList();
if (!string.IsNullOrEmpty(tupleToken.SourceName))
{
var optionText = ArrayRunEnumSegment.GetOptions(model, tupleToken.SourceName).Where(option => option.MatchesPartial(optionToken));
results.AddRange(CreateTupleEnumSingleElementAutocompleteOptions(fieldName, tupleGroup, tupleTokens, optionText, lineEnd));
}
else if (tupleToken.BitWidth == 1)
{
var optionText = new[] { "false", "true" }.Where(option => option.MatchesPartial(optionToken));
results.AddRange(CreateTupleEnumSingleElementAutocompleteOptions(fieldName, tupleGroup, tupleTokens, optionText, lineEnd));
}
}
}
return(results);
}
public IReadOnlyList <AutocompleteItem> GetAutoCompleteOptions(string line, int caretLineIndex, int caretCharacterIndex)
{
if (endStream is FixedLengthStreamStrategy flss && flss.Count == 1)
{
return(GetAutoCompleteOptionsForSingleElementStream(line, caretCharacterIndex));
}
var results = new List <AutocompleteItem>();
if (line.Trim().Length == 0)
{
return(results);
}
var lineStart = line.Substring(0, caretCharacterIndex);
var lineEnd = line.Substring(caretCharacterIndex);
var tokens = Tokenize(lineStart);
if (ElementContent.Count < tokens.Count)
{
return(results);
}
var targetSegment = ElementContent[Math.Max(0, tokens.Count - 1)];
var currentToken = tokens.Count == 0 ? string.Empty : tokens[tokens.Count - 1];
if (targetSegment is ArrayRunEnumSegment enumSegment)
{
if (currentToken.StartsWith("\""))
{
currentToken = currentToken.Substring(1);
}
if (currentToken.EndsWith("\""))
{
currentToken = currentToken.Substring(0, currentToken.Length - 1);
}
var optionText = enumSegment.GetOptions(model).Where(option => option?.MatchesPartial(currentToken) ?? false);
results.AddRange(CreateEnumAutocompleteOptions(tokens, optionText, lineEnd));
}
else if (targetSegment is ArrayRunTupleSegment tupleGroup)
{
var tupleTokens = currentToken.Split(" ").ToList();
if (tupleTokens[0].StartsWith("("))
{
tupleTokens[0] = tupleTokens[0].Substring(1);
}
Recombine(tupleTokens, "\"", "\"");
var visibleTupleElements = tupleGroup.Elements.Where(element => !string.IsNullOrEmpty(element.Name)).ToList();
var optionToken = tupleTokens.Last();
if (visibleTupleElements.Count >= tupleTokens.Count)
{
var tupleToken = visibleTupleElements[tupleTokens.Count - 1];
if (optionToken.StartsWith("\""))
{
optionToken = optionToken.Substring(1);
}
if (optionToken.EndsWith("\""))
{
optionToken = optionToken.Substring(0, optionToken.Length - 1);
}
if (!string.IsNullOrEmpty(tupleToken.SourceName))
{
var optionText = ArrayRunEnumSegment.GetOptions(model, tupleToken.SourceName).Where(option => option.MatchesPartial(optionToken));
results.AddRange(CreateTupleEnumAutocompleteOptions(tokens, tupleGroup, tupleTokens, optionText, lineEnd));
}
else if (tupleToken.BitWidth == 1)
{
var options = new[] { "false", "true" }.Where(option => option.MatchesPartial(optionToken));
results.AddRange(CreateTupleEnumAutocompleteOptions(tokens, tupleGroup, tupleTokens, options, lineEnd));
}
}
}
return(results);
}
