public bool CanBuild(int start, StringRange content)
{
var startOfNextLine = content.StartOfNextLine(start);
bool isMatch = content.HasStringAt(startOfNextLine, "---");
return isMatch;
}
private ILinkResponse TryParseFullPath([NotNull] string input, [NotNull] StringRange range)
{
try
{
var path = ConvertToAbsolutePath(VirtualFileSystemPath.Parse(input, InteractionContext.SolutionContext));
if (path == null)
{
return(null);
}
if (path.ExtensionNoDot == "umap")
{
//TO-DO
return(null);
}
if (path.ExtensionNoDot == "uasset")
{
return(new LinkResponseBlueprint(new FString(path.ToUri().AbsolutePath), range));
}
return(new LinkResponseFilePath(new FString(path.ToUri().AbsolutePath), range));
}
catch (InvalidPathException e)
{
_logger.Warn(e);
}
catch (Exception e)
{
_logger.Error(e, "occured while trying parse full path");
}
return(null);
}
public static Suggestions Create(string command, Suggestion[] suggestions)
{
if (suggestions.Length == 0)
{
return(NoSuggestions);
}
var start = int.MaxValue;
var end = int.MinValue;
foreach (var suggestion in suggestions)
{
start = Math.Min(suggestion.Range.Start, start);
end = Math.Max(suggestion.Range.End, end);
}
var range = new StringRange(start, end);
var texts = new HashSet <Suggestion>();
foreach (var suggestion in suggestions)
{
texts.Add(suggestion.Expand(command, range));
}
var sorted = new List <Suggestion>(texts);
sorted.Sort((a, b) => a.CompareToIgnoreCase(b));
return(new Suggestions(range, sorted));
}
public override Block Build(int start, StringRange content, out int end)
{
int startOfLine = start;
var items = new List<Item>();
Item lastItem = null;
bool foundItem = false;
do
{
int startOfItem = content.IndexOf(' ', startOfLine) + 1;
int endOfItem = FindEndOfItem(content, startOfItem);
IEnumerable<Span> spans = _inlineParser.Parse(new StringRange(content, startOfItem, endOfItem));
lastItem = new Item(
content,
startOfItem,
endOfItem,
spans);
items.Add(lastItem);
startOfLine = content.StartOfNextLine(endOfItem);
if (startOfLine == -1)
break;
foundItem = _expression.IsMatch(content.Document, startOfLine);
} while (foundItem);
// special case when content ends
end = content.EndOfLine(lastItem.End);
return new List(content, start, end, true, items);
}
public void Build()
{
/* given */
int listEnd;
var markdown = new StringBuilder();
markdown.Append("- item 1\n");
markdown.Append("- item\n");
markdown.Append(" this is item two 2\n");
markdown.Append("- item 3\n");
var listRange = new StringRange(markdown.ToString());
var builder = new UnorderedListBuilder('-');
/* when */
var list = (List)builder.Build(0, listRange, out listEnd);
/* then */
list.Items.Should().HaveCount(3);
var item1 = list.Items.ElementAt(0);
item1.ToString().ShouldBeEquivalentTo("item 1");
var item2 = list.Items.ElementAt(1);
item2.ToString().ShouldBeEquivalentTo("item\n this is item two 2");
var item3 = list.Items.ElementAt(2);
item3.ToString().ShouldBeEquivalentTo("item 3");
}
public Document Parse(string markdown)
{
foreach (IPreprocessor processor in Pre)
{
markdown = processor.Process(markdown);
}
var blocks = new List<Block>();
if (string.IsNullOrWhiteSpace(markdown))
return new Document(blocks, markdown);
var markdownContent = new StringRange(markdown);
foreach (Block block in ParseBlocks(markdownContent))
{
// skip empty paragraphs
var paragraph = block as Paragraph;
if (paragraph != null)
{
if (paragraph.IsEmpty())
continue;
}
// skip empty lines
if (_skipEmptyLines && block is EmptyLine)
continue;
blocks.Add(block);
}
ResolveReferences(blocks);
return new Document(blocks, markdown);
}
void ITextEditor.ReplaceText (StringRange range, string text)
{
var b = this.GetPosition (BeginningOfDocument, range.Location);
var e = this.GetPosition (BeginningOfDocument, range.Location + range.Length);
var r = this.GetTextRange (b, e);
ReplaceText (r, text);
}
public void VerifyThatPropertiesAreSetByConstructor()
{
var stringRange = new StringRange(this.start, this.length);
Assert.AreEqual(this.start, stringRange.Start);
Assert.AreEqual(this.length, stringRange.Length);
}
public async Task getCompletionSuggestions_execute_simulation_partial()
{
var execute = _subject.Register(r => r.Literal("execute"));
_subject.Register(r =>
r.Literal("execute")
.Then(
r.Literal("as")
.Then(r.Literal("bar").Redirect(execute))
.Then(r.Literal("baz").Redirect(execute))
)
.Then(
r.Literal("store")
.Then(
r.Argument("name", Arguments.Word())
.Redirect(execute)
)
)
.Then(
r.Literal("run").Executes(e => 0)
)
);
var parse = _subject.Parse("execute as bar as ", _source);
var result = await _subject.GetCompletionSuggestions(parse);
result.Range.Should().BeEquivalentTo(StringRange.At(18));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion>
{
new Suggestion.Suggestion(StringRange.At(18), "bar"),
new Suggestion.Suggestion(StringRange.At(18), "baz")
});
}
public void Calculate_OneSetOfBrackets_PerformsCorrectCalls()
{
var equation = "1+{2+3}";
var deepestNest1 = new StringRange()
{
StartIndex = 2, Length = 5
};
var parts1 = "2+3";
A.CallTo(() => _nestingIdentifier.FindDeepestNest(equation)).Returns(deepestNest1);
A.CallTo(() => _mathsResolver.ResolveSection(parts1)).Returns("5");
var equation2 = "1+5";
StringRange deepestNest2 = null;
A.CallTo(() => _nestingIdentifier.FindDeepestNest(equation2)).Returns(deepestNest2);
A.CallTo(() => _mathsResolver.ResolveSection(equation2)).Returns("6");
var response = _calculator.Calculate(equation);
response.Should().Be(6);
A.CallTo(() => _nestingIdentifier.FindDeepestNest(equation)).MustHaveHappened();
A.CallTo(() => _mathsResolver.ResolveSection(parts1)).MustHaveHappened();
A.CallTo(() => _nestingIdentifier.FindDeepestNest(equation2)).MustHaveHappened();
A.CallTo(() => _mathsResolver.ResolveSection(equation2)).MustHaveHappened();
}
public void MultilineItems()
{
/* given */
int listEnd;
var markdown = new StringBuilder();
markdown.Append("- item\n");
markdown.Append(" something here for the next line of the item\n");
markdown.Append("- item\n");
markdown.Append(" this is item two\n");
markdown.Append("- item\n");
markdown.Append("should not the part of item 3\n");
var listRange = new StringRange(markdown.ToString());
var builder = new UnorderedListBuilder('-');
/* when */
var list = (List)builder.Build(0, listRange, out listEnd);
/* then */
list.Items.Should().HaveCount(3);
var item1 = list.Items.ElementAt(0);
item1.ToString().ShouldBeEquivalentTo("item\n something here for the next line of the item");
var item2 = list.Items.ElementAt(1);
item2.ToString().ShouldBeEquivalentTo("item\n this is item two");
var item3 = list.Items.ElementAt(2);
item3.ToString().ShouldBeEquivalentTo("item");
}
protected int FindEndOfItem(StringRange content, int position)
{
/*********************************************
* item will end when the next line is not
* indented by at least one space
* ******************************************/
for (int possibleEnd = position; possibleEnd < content.End; possibleEnd++)
{
possibleEnd = content.EndOfLine(possibleEnd, true);
var lineStart = content.StartOfNextLine(possibleEnd);
if (lineStart == -1)
{
return content.EndOfLine(possibleEnd);
}
// if line does not start with space then last line was the end of item
if (!content.HasCharactersAt(lineStart, ' '))
{
return content.EndOfLine(possibleEnd);
}
}
return position;
}
public LinkDefinitionList(
StringRange parent,
int start,
int end,
IEnumerable<LinkDefinition> definitions) : base(parent, start, end)
{
Definitions = definitions;
}
public override bool CanBuild(int start, StringRange content)
{
if (!content.IsStartOfLine(start))
return false;
bool isMatch = _expression.IsMatch(content.Document, start);
return isMatch;
}
public override Span Build(int position, StringRange content, out int lastPosition)
{
var atPosition = content.IndexOf('@', position);
lastPosition = content.IndexOf(' ', atPosition)- 1;
return new UserName(content, atPosition, lastPosition);
}
void ITextEditor.ReplaceText(StringRange range, string text)
{
var b = this.GetPosition(BeginningOfDocument, range.Location);
var e = this.GetPosition(BeginningOfDocument, range.Location + range.Length);
var r = this.GetTextRange(b, e);
ReplaceText(r, text);
}
public Block Build(int start, StringRange content, out int end)
{
int endOfHeadingText = content.EndOfLine(start, false);
int startOfMarker = content.StartOfNextLine(endOfHeadingText);
end = content.EndOfLine(startOfMarker, false);
return new Heading(content, start, endOfHeadingText, 2);
}
public bool CanBuild(int start, StringRange content)
{
// [key]: url
// [123]: url
var isMatch = _expression.IsMatch(content.Document, start);
return isMatch;
}
public override bool CanBuild(int start, StringRange content)
{
if (!content.IsStartOfLine(start))
return false;
bool starts = content.HasCharactersAt(start, _startsWith, ' ');
return starts;
}
private ILinkResponse TryParseFullName([NotNull] string s, [NotNull] StringRange range,
IRdCall <FString, bool> isBlueprintPathName)
{
var path = new FString(s);
return(isBlueprintPathName.Sync(path)
? new LinkResponseBlueprint(path, range)
: null);
}
public SuggestionsBuilder Suggest(string text, IMessage tooltip)
{
if (text.Equals(Remaining))
{
return(this);
}
_result.Add(new Suggestion(StringRange.Between(Start, Input.Length), text, tooltip));
return(this);
}
public override bool CanBuild(int position, StringRange content)
{
var atPosition = content.IndexOf('@', position);
if (atPosition == -1)
return false;
return true;
}
public void IsStartOfLine_ContentStart()
{
/* given */
const string text = "0123456789";
var stringRange = new StringRange(text);
/* when */
/* then */
stringRange.IsStartOfLine(0).ShouldBeEquivalentTo(true);
}
public LinkDefinition(
StringRange parent,
int start,
int end,
StringRange key,
StringRange url) : base(parent, start, end)
{
Key = key;
Url = url;
}
public void IndexOfAfterEnd()
{
/* given */
const string text = "0123456789";
var stringRange = new StringRange(text, 2, 7);
/* when */
/* then */
stringRange.IndexOf('8').ShouldBeEquivalentTo(-1);
}
public Block Build(int start, StringRange content, out int end)
{
// \n\n
end = content.EndOfLine(start, true);
if (content.HasCharactersAt(end + 1, '\n'))
end = content.EndOfLine(end + 1, true);
return new EmptyLine(content, start, end);
}
public LinkSpan(
StringRange parent,
int start,
int end,
StringRange title,
StringRange url) : base(parent, start, end)
{
Title = title;
Url = url;
}
public GistBlock(
StringRange parent,
int start,
int end,
StringRange userName,
StringRange gistId) : base(parent, start, end)
{
UserName = userName;
GistId = gistId;
}
public void suggest_multiple()
{
var result = _builder.Suggest("world!").Suggest("everybody").Suggest("weekend").Build();
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.Between(6, 7), "everybody"), new Suggestion.Suggestion(StringRange.Between(6, 7), "weekend"), new Suggestion.Suggestion(StringRange.Between(6, 7), "world!")
});
result.Range.Should().BeEquivalentTo(StringRange.Between(6, 7));
result.IsEmpty().Should().Be(false);
}
public IEnumerable<Span> Parse(StringRange content)
{
var spans = new List<Span>(ParseCore(content));
// strip last new line
var last = spans.Last();
if (last is NewLineSpan)
spans.Remove(last);
return spans;
}
public List(
StringRange parent,
int start,
int end,
bool isOrdered,
IEnumerable<Item> items)
: base(parent, start, end)
{
Items = items;
IsOrdered = isOrdered;
}
public void Length4()
{
/* given */
const string text = "test";
/* when */
var stringRange = new StringRange(text);
int length = stringRange.Length;
/* then */
length.ShouldBeEquivalentTo(4);
}
public void Length2()
{
/* given */
var stringRange = new StringRange("01");
/* when */
int length = stringRange.Length;
/* then */
length.ShouldBeEquivalentTo(2);
}
public void merge_single()
{
var suggestions = new Suggestions(StringRange.At(5), new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.At(5), "ar")
});
var merged = Suggestions.Merge("foo b", new List <Suggestions> {
suggestions
});
merged.Should().BeEquivalentTo(suggestions);
}
public static DynValue sub(ScriptExecutionContext executionContext, CallbackArguments args)
{
var arg_s = args.AsType(0, "sub", DataType.String);
var arg_i = args.AsType(1, "sub", DataType.Number, true);
var arg_j = args.AsType(2, "sub", DataType.Number, true);
var range = StringRange.FromLuaRange(arg_i, arg_j, -1);
string s = range.ApplyToString(arg_s.String);
return(DynValue.NewString(s));
}
public override bool CanBuild(int position, StringRange content)
{
bool starts = content[position] == '*';
if (position >= content.End)
return starts;
if (content[position + 1] == '.')
return false;
return starts;
}
public void IndexOf()
{
/* given */
const string text = "0123456789";
var stringRange = new StringRange(text, 2, 7);
/* when */
var indexOfFour = stringRange.IndexOf('4');
/* then */
indexOfFour.ShouldBeEquivalentTo(4);
}
protected IEnumerable<Block> ParseBlocks(StringRange document)
{
int paragraphStart = -1;
int paragraphEnd = -1;
bool paragraphStarted = false;
// there should be one monster builder always in builders
ParagraphBuilder monsterBuilder = _builders.OfType<ParagraphBuilder>().Single();
for (int start = 0; start < document.Length; start++)
{
IBlockBuilder builder = GetBuilder(start, document);
// paragraph is special as it just eats
// everything else the others don't
// want. Special muncher!
if (builder is ParagraphBuilder)
{
if (!paragraphStarted)
{
paragraphStart = start;
paragraphStarted = true;
}
paragraphEnd = start;
continue;
}
if (builder is EmptyLineBuilder && paragraphStarted)
{
// include the emtpty line character into the end
paragraphEnd = start;
}
// have to kill the monster so others can
// feed too
if (paragraphStarted)
{
// yield it and then kill it!
yield return monsterBuilder.Build(paragraphStart, paragraphEnd, document);
paragraphStarted = false;
}
yield return BuildBlock(builder, start, document, out start);
}
// so one monster got away
// run after it as it's yielding
if (paragraphStarted)
{
yield return monsterBuilder.Build(paragraphStart, paragraphEnd, document);
}
}
private IEnumerable<Span> ParseCore(StringRange content)
{
bool textSpanStarted = false;
int textSpanStart = -1;
int textSpanEnd = -1;
for (int position = content.Start; position <= content.End; position++)
{
// get span builder
SpanBuilder builder = GetBuilder(position, content);
/*******************************************************
* We don't want to generate char spans with only single
* character so we combine it to one text span.
*
* CharSpanBuilder cannot actually build anything so it
* acts only as marker :)
* *****************************************************/
if (builder is CharSpanBuilder)
{
// text span not started
if (!textSpanStarted)
{
// start from current position
textSpanStart = position;
textSpanStarted = true;
}
// just update the end position
textSpanEnd = position;
continue;
}
if (textSpanStarted)
{
// so new span is starting and we have unfinished text span
// which we need to yield first
yield return new TextSpan(content, textSpanStart, textSpanEnd);
textSpanStarted = false;
}
// build span and move position to new position
yield return builder.Build(position, content, out position);
}
// so the only or the last span was the text span?
// lets yield it so it's not left orphaned
if (textSpanStarted)
{
yield return new TextSpan(content, textSpanStart, textSpanEnd);
}
}
public async Task getCompletionSuggestions_rootCommands()
{
_subject.Register(r => r.Literal("foo"));
_subject.Register(r => r.Literal("bar"));
_subject.Register(r => r.Literal("baz"));
var result = await _subject.GetCompletionSuggestions(_subject.Parse("", _source));
result.Range.Should().BeEquivalentTo(StringRange.At(0));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.At(0), "bar"), new Suggestion.Suggestion(StringRange.At(0), "baz"), new Suggestion.Suggestion(StringRange.At(0), "foo")
});
}
public async Task getCompletionSuggestions_rootCommands_partial_withInputOffset()
{
_subject.Register(r => r.Literal("foo"));
_subject.Register(r => r.Literal("bar"));
_subject.Register(r => r.Literal("baz"));
var result = await _subject.GetCompletionSuggestions(_subject.Parse(InputWithOffset("Zb", 1), _source));
result.Range.Should().BeEquivalentTo(StringRange.Between(1, 2));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.Between(1, 2), "bar"), new Suggestion.Suggestion(StringRange.Between(1, 2), "baz")
});
}
public override void Parse(StringReader reader, CommandContextBuilder <TSource> contextBuilder)
{
var start = reader.Cursor;
var end = Parse(reader);
if (end > -1)
{
contextBuilder.WithNode(this, StringRange.Between(start, end));
return;
}
throw CommandSyntaxException.BuiltInExceptions.LiteralIncorrect().CreateWithContext(reader, Literal);
}
/// <inheritdoc/>
public override StringRange GetPrecedingText(int visualColumnLimit, ITextRunConstructionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var relativeOffset = visualColumnLimit - VisualColumn;
var text = context.GetText(context.VisualLine.FirstDocumentLine.Offset + RelativeTextOffset, relativeOffset);
var range = new StringRange(text.Text, text.Offset, text.Count);
return(range);
}
public async Task getCompletionSuggestions_redirectPartial_withInputOffset()
{
var actual = _subject.Register(r => r.Literal("actual").Then(r.Literal("sub")));
_subject.Register(r => r.Literal("redirect").Redirect(actual));
var parse = _subject.Parse(InputWithOffset("/redirect s", 1), _source);
var result = await _subject.GetCompletionSuggestions(parse);
result.Range.Should().BeEquivalentTo(StringRange.Between(10, 11));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.Between(10, 11), "sub")
});
}
public async Task getCompletionSuggestions_redirect()
{
var actual = _subject.Register(r => r.Literal("actual").Then(r.Literal("sub")));
_subject.Register(r => r.Literal("redirect").Redirect(actual));
var parse = _subject.Parse("redirect ", _source);
var result = await _subject.GetCompletionSuggestions(parse);
result.Range.Should().BeEquivalentTo(StringRange.At(9));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.At(9), "sub")
});
}
public Block Build(int start, StringRange content, out int end)
{
end = content.EndOfLine(start, false);
var counter = start;
var level = 0;
while (content[counter] == '#')
{
level++;
counter++;
}
return new Heading(content, counter + 1, end, level);
}
public void TestComparator()
{
var sorted = new SortedSet <StringRange>(new StringRangeComparator());
string[][] TEST_SET =
{
new[] { "B", "G" },
new[] { "B", "F" },
new[] { null, "E" },
new[] { "A", "F" },
new[] { "A", "G" }
};
int[] EXPECTED_INDEX = { 2, 3, 4, 1, 0 };
// Sort
var ranges = new StringRange[TEST_SET.Length];
for (var i = 0; i < TEST_SET.Length; i++)
{
ranges[i] = new StringRange(TEST_SET[i][0], TEST_SET[i][1]);
sorted.Add(ranges[i]);
}
log.Info("sorted=" + sorted);
// Check results
var count = 0;
for (IEnumerator <StringRange> i = sorted.GetEnumerator(); i.MoveNext();)
{
StringRange range = i.Current;
var indexExpected = EXPECTED_INDEX[count];
var expected = ranges[indexExpected];
log.Debug(
".testComparator count=" +
count +
" range=" +
range +
" expected=" +
expected);
Assert.AreEqual(range, expected, "failed at count " + count);
count++;
}
Assert.AreEqual(count, TEST_SET.Length);
}
private async Task TestSuggestions(string contents, int cursor, StringRange range, params string[] suggestions)
{
var result = await _subject.GetCompletionSuggestions(_subject.Parse(contents, _source), cursor);
result.Range.Should().BeEquivalentTo(range);
var expected = new List <Suggestion.Suggestion>();
foreach (var suggestion in suggestions)
{
expected.Add(new Suggestion.Suggestion(range, suggestion));
}
result.List.Should().BeEquivalentTo(expected);
}
public void Calculate_NoBrackets_ReturnsDirectCalculation()
{
var equation = "1";
StringRange deepestNest = null;
var section = "1";
A.CallTo(() => _nestingIdentifier.FindDeepestNest(equation)).Returns(deepestNest);
A.CallTo(() => _mathsResolver.ResolveSection(section)).Returns("1");
var response = _calculator.Calculate(equation);
response.Should().Be(1);
A.CallTo(() => _nestingIdentifier.FindDeepestNest(equation)).MustHaveHappened();
A.CallTo(() => _mathsResolver.ResolveSection(section)).MustHaveHappened();
}
private static DynValue PerformByteLike(DynValue vs, DynValue vi, DynValue vj, Func <int, int> filter)
{
var range = StringRange.FromLuaRange(vi, vj);
string s = range.ApplyToString(vs.String);
int length = s.Length;
var rets = new DynValue[length];
for (int i = 0; i < length; ++i)
{
rets[i] = DynValue.NewNumber(filter(s[i]));
}
return(DynValue.NewTuple(rets));
}
public void merge_multiple()
{
var a = new Suggestions(StringRange.At(5), new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.At(5), "ar"), new Suggestion.Suggestion(StringRange.At(5), "az"), new Suggestion.Suggestion(StringRange.At(5), "Az")
});
var b = new Suggestions(StringRange.Between(4, 5), new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.Between(4, 5), "foo"), new Suggestion.Suggestion(StringRange.Between(4, 5), "qux"), new Suggestion.Suggestion(StringRange.Between(4, 5), "apple"), new Suggestion.Suggestion(StringRange.Between(4, 5), "Bar")
});
var merged = Suggestions.Merge("foo b", new List <Suggestions> {
a, b
});
merged.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.Between(4, 5), "apple"), new Suggestion.Suggestion(StringRange.Between(4, 5), "bar"), new Suggestion.Suggestion(StringRange.Between(4, 5), "Bar"), new Suggestion.Suggestion(StringRange.Between(4, 5), "baz"), new Suggestion.Suggestion(StringRange.Between(4, 5), "bAz"), new Suggestion.Suggestion(StringRange.Between(4, 5), "foo"), new Suggestion.Suggestion(StringRange.Between(4, 5), "qux")
});
}
private ILinkResponse TryParseFullName([NotNull] string s, [NotNull] StringRange range,
IRdCall <FString, bool> isBlueprintPathName)
{
var path = new FString(s);
try
{
return(isBlueprintPathName.Sync(path)
? new LinkResponseBlueprint(path, range)
: null);
}
catch (Exception e)
{
_logger.Warn(e, "[UnrealLink]: Failed to parse Blueprint string");
return(null);
}
}
public void Codeblock()
{
/* given */
var text = new StringRange("`bool IsCode = true;`");
var parser = new InlineParser();
/* when */
var result = parser.Parse(text).ToList();
/* then */
result.Should().HaveCount(1);
result.Should().OnlyContain(span => span is CodeblockSpan);
// verify link details
var codeSpan = result.First() as CodeblockSpan;
codeSpan.ToString().ShouldBeEquivalentTo("bool IsCode = true;");
}
public async Task getCompletionSuggestions_SubCommands_partial_withInputOffset()
{
_subject.Register(r =>
r.Literal("parent")
.Then(r.Literal("foo"))
.Then(r.Literal("bar"))
.Then(r.Literal("baz"))
);
var parse = _subject.Parse(InputWithOffset("junk parent b", 5), _source);
var result = await _subject.GetCompletionSuggestions(parse);
result.Range.Should().BeEquivalentTo(StringRange.Between(12, 13));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.Between(12, 13), "bar"), new Suggestion.Suggestion(StringRange.Between(12, 13), "baz")
});
}
internal ILinkResponse ResolveLink(LinkRequest @struct, IRdCall <FString, bool> isBlueprintPathName)
{
// ReSharper disable once LocalFunctionCanBeMadeStatic
string SqueezeBorders(string s, out int l, out int r)
{
l = 0;
r = s.Length;
if (s.EndsWith("."))
{
--r;
}
if (PairSymbol.TryGetValue(s[r - 1], out var value))
{
l = s.AsSpan(l, r - l - 1).LastIndexOf(value) + 1;
--r;
}
return(s.Substring(l, r - l));
}
var link = @struct.Data.Data;
var squeezed = SqueezeBorders(link, out var left, out var right);
var range = new StringRange(left, right);
var fullPath = TryParseFullPath(squeezed, range);
if (fullPath != null)
{
return(fullPath);
}
var fullName = TryParseFullName(squeezed, range, isBlueprintPathName);
if (fullName != null)
{
return(fullName);
}
return(new LinkResponseUnresolved());
}
public Suggestion Expand(string command, StringRange range)
{
if (range.Equals(Range))
{
return(this);
}
var result = new StringBuilder();
if (range.Start < Range.Start)
{
result.Append(command.Substring(range.Start, Range.Start - range.Start));
}
result.Append(Text);
if (range.End > Range.End)
{
result.Append(command.Substring(Range.End, range.End - Range.End));
}
return(new Suggestion(range, result.ToString(), Tooltip));
}
public async Task TestSuggestions()
{
var empty = await _node.ListSuggestions(_contextBuilder.Build(""), new SuggestionsBuilder("", 0));
empty.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.At(0), "foo")
});
var foo = await _node.ListSuggestions(_contextBuilder.Build("foo"), new SuggestionsBuilder("foo", 0));
foo.IsEmpty().Should().Be(true);
var food = await _node.ListSuggestions(_contextBuilder.Build("food"), new SuggestionsBuilder("food", 0));
food.IsEmpty().Should().Be(true);
var b = await _node.ListSuggestions(_contextBuilder.Build("b"), new SuggestionsBuilder("b", 0));
b.IsEmpty().Should().Be(true);
}
public async Task getCompletionSuggestions_redirect_lots()
{
var loop = _subject.Register(r => r.Literal("redirect"));
_subject.Register(r =>
r.Literal("redirect")
.Then(
r.Literal("loop")
.Then(
r.Argument("loop", Arguments.Integer())
.Redirect(loop)
)
)
);
var result = await _subject.GetCompletionSuggestions(_subject.Parse("redirect loop 1 loop 02 loop 003 ", _source));
result.Range.Should().BeEquivalentTo(StringRange.At(33));
result.List.Should().BeEquivalentTo(new List <Suggestion.Suggestion> {
new Suggestion.Suggestion(StringRange.At(33), "loop")
});
}
public override FilterValueSetParam GetFilterValue(
MatchedEventMap matchedEvents,
ExprEvaluatorContext exprEvaluatorContext,
StatementContextFilterEvalEnv filterEvalEnv)
{
ExprFilterSpecLookupable lookupable = this.Lkupable.Make(matchedEvents, exprEvaluatorContext);
Object range;
if (lookupable.ReturnType == typeof(string))
{
var begin = (string)Min.GetFilterValue(matchedEvents, exprEvaluatorContext, filterEvalEnv);
var end = (string)Max.GetFilterValue(matchedEvents, exprEvaluatorContext, filterEvalEnv);
range = new StringRange(begin, end);
}
else
{
var begin = (double)Min.GetFilterValue(matchedEvents, exprEvaluatorContext, filterEvalEnv);
var end = (double)Max.GetFilterValue(matchedEvents, exprEvaluatorContext, filterEvalEnv);
range = new DoubleRange(begin, end);
}
return(new FilterValueSetParamImpl(lookupable, FilterOperator, range));
}
public async Task getCompletionSuggestions_movingCursor_redirect()
{
var actualOne = _subject.Register(r => r.Literal("actual_one")
.Then(r.Literal("faz"))
.Then(r.Literal("fbz"))
.Then(r.Literal("gaz"))
);
_subject.Register(r => r.Literal("actual_two"));
_subject.Register(r => r.Literal("redirect_one").Redirect(actualOne));
_subject.Register(r => r.Literal("redirect_two").Redirect(actualOne));
await TestSuggestions("redirect_one faz ", 0, StringRange.At(0), "actual_one", "actual_two", "redirect_one", "redirect_two");
await TestSuggestions("redirect_one faz ", 9, StringRange.Between(0, 9), "redirect_one", "redirect_two");
await TestSuggestions("redirect_one faz ", 10, StringRange.Between(0, 10), "redirect_one");
await TestSuggestions("redirect_one faz ", 12, StringRange.At(0));
await TestSuggestions("redirect_one faz ", 13, StringRange.At(13), "faz", "fbz", "gaz");
await TestSuggestions("redirect_one faz ", 14, StringRange.Between(13, 14), "faz", "fbz");
await TestSuggestions("redirect_one faz ", 15, StringRange.Between(13, 15), "faz");
await TestSuggestions("redirect_one faz ", 16, StringRange.At(0));
await TestSuggestions("redirect_one faz ", 17, StringRange.At(0));
}
