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)); }