public void GetTagsIgnoresDoubleQuotesAroundAttributeValue()
        {
            ITagSpan <ClassificationTag> lastSpan = this.GetTags("<#@ \"value\"").Last();

            Assert.Equal(this.attributeValueClassification, lastSpan.Tag.ClassificationType);
            Assert.Equal("value", lastSpan.Span.GetText());
        }
        public void GetTagsIgnoresEqualsBetweenAttributeNameAndAttributeValue()
        {
            ITagSpan <ClassificationTag> lastSpan = this.GetTags("<#@ directive attribute =").Last();

            Assert.Equal(this.attributeNameClassification, lastSpan.Tag.ClassificationType);
            Assert.Equal("attribute", lastSpan.Span.GetText());
        }
Exemple #3
0
        /// <summary>
        /// The get tags.
        /// </summary>
        /// <param name="spans">
        /// The spans.
        /// </param>
        /// <returns>
        /// The
        ///     <see>
        ///         <cref>IEnumerable</cref>
        ///     </see>
        ///     .
        /// </returns>
        public IEnumerable <ITagSpan <SonarTag> > GetTags(NormalizedSnapshotSpanCollection spans)
        {
            if (spans.Count == 0)
            {
                yield break;
            }

            if (spans.Count == 0)
            {
                yield break;
            }

            if (this.sonarTags.Count == 0)
            {
                yield break;
            }

            ITextSnapshot snapshot = spans[0].Snapshot;

            foreach (SonarTag tag in this.sonarTags)
            {
                ITagSpan <SonarTag> tagSpan = tag.ToTagSpan(snapshot);
                if (tagSpan.Span.Length == 0)
                {
                    continue;
                }

                yield return(tagSpan);
            }
        }
        /// <summary>
        /// The get tags.
        /// </summary>
        /// <param name="spans">
        /// The spans.
        /// </param>
        /// <returns>
        /// The System.Collections.Generic.IEnumerable`1[T -&gt; Microsoft.VisualStudio.Text.Tagging.ITagSpan`1[T -&gt;
        ///     SmartTags.Coverage.HighlightCoverageTag]].
        /// </returns>
        public IEnumerable <ITagSpan <CoverageTag> > GetTags(NormalizedSnapshotSpanCollection spans)
        {
            if (spans.Count == 0)
            {
                yield break;
            }

            if (!SonarQubeViewModelFactory.SQViewModel.ServerViewModel.CoverageInEditorEnabled)
            {
                yield break;
            }

            if (this.coverageTags.Count == 0)
            {
                yield break;
            }

            ITextSnapshot snapshot = spans[0].Snapshot;

            foreach (CoverageTag tag in this.coverageTags)
            {
                ITagSpan <CoverageTag> tagSpan = tag.ToTagSpan(snapshot);
                if (tagSpan.Span.Length == 0)
                {
                    continue;
                }

                yield return(tagSpan);
            }
        }
        private bool TryGetUrlSpan(int line, int column, out ITagSpan <IUrlTag> urlSpan)
        {
            urlSpan = null;

            SnapshotPoint point;

            if (!TryToSnapshotPoint(TextView.TextSnapshot, line, column, out point))
            {
                return(false);
            }

            SnapshotSpan span = new SnapshotSpan(point, 0);

            foreach (IMappingTagSpan <IUrlTag> current in _urlTagAggregator.GetTags(span))
            {
                NormalizedSnapshotSpanCollection spans = current.Span.GetSpans(TextView.TextSnapshot);
                if (spans.Count == 1 && spans[0].Length == current.Span.GetSpans(current.Span.AnchorBuffer)[0].Length && spans[0].Contains(span.Start))
                {
                    urlSpan = new TagSpan <IUrlTag>(spans[0], current.Tag);
                    return(true);
                }
            }

            return(false);
        }
 private static bool IsUrlSpanValid(ITagSpan <IUrlTag> urlTagSpan)
 {
     return(urlTagSpan != null &&
            urlTagSpan.Tag != null &&
            urlTagSpan.Tag.Url != null &&
            urlTagSpan.Tag.Url.IsAbsoluteUri);
 }
        public void GetTagsReturnsAttributeValueSpanForAttributeValueToken()
        {
            ITagSpan <ClassificationTag> span = this.GetTags("<#@ \"value\" #>").ElementAt(1);

            Assert.Equal(this.attributeValueClassification, span.Tag.ClassificationType);
            Assert.Equal("value", span.Span.GetText());
        }
        void NavigateTo(ITagSpan<GoToDefinitionTag> navigateToTagSpan) {
            _textView.Selection.Clear();

            var location = navigateToTagSpan.Tag.Location;

            NavLanguagePackage.GoToLocationInPreviewTab(location);            
        }
Exemple #9
0
            public bool Equals(ITagSpan <TTag> x, ITagSpan <TTag> y)
            {
                if (x.Span != y.Span)
                {
                    return(false);
                }

                return(_tagComparer.Equals(x.Tag, y.Tag));
            }
Exemple #10
0
        public void AddTag(ITagSpan <TTag> tag)
        {
            if (tag == null)
            {
                return;
            }

            _resultTagsList.Add(tag);
        }
Exemple #11
0
        bool GoToDiagnostic(ITagSpan <DiagnosticErrorTag> tagSpan)
        {
            if (tagSpan == null)
            {
                return(false);
            }

            return(_textView.TryMoveCaretToAndEnsureVisible(tagSpan.Span.Start, _outliningManagerService));
        }
Exemple #12
0
        public void AddTag(ITagSpan <TTag> tag)
        {
            if (tag == null || CancellationToken.IsCancellationRequested)
            {
                return;
            }

            tagsQueue.Enqueue(tag);
        }
        protected virtual bool IsMultilineTagSpan(ITagSpan <TTag> span)
        {
            Contract.Requires <ArgumentNullException>(span != null, "span");
            if (span.Span.IsEmpty)
            {
                return(false);
            }

            return(span.Span.Start.GetContainingLine().LineNumber != span.Span.End.GetContainingLine().LineNumber);
        }
Exemple #14
0
        protected virtual bool IsMultilineTagSpan([NotNull] ITagSpan <TTag> span)
        {
            Requires.NotNull(span, nameof(span));
            if (span.Span.IsEmpty)
            {
                return(false);
            }

            return(span.Span.Start.GetContainingLine().LineNumber != span.Span.End.GetContainingLine().LineNumber);
        }
            private void AddOutliningTagToBQL(TextSpan span)
            {
                if (AcuminatorVSPackage.Instance?.UseBqlOutlining == false)
                {
                    return;
                }

                ITagSpan <IOutliningRegionTag> tag = span.ToOutliningTagSpan(_tagger.Snapshot);

                _tagger.OutliningsTagsCache.AddTag(tag);
            }
            private void AddOutliningTagToBQL(TextSpan span)
            {
                if (!_tagger.Provider.Package.UseBqlOutlining)
                {
                    return;
                }

                ITagSpan <IOutliningRegionTag> tag = span.ToOutliningTagSpan(_tagger.Snapshot);

                _tagger.OutliningsTagsCache.AddTag(tag);
            }
        public static void GetTagsReturnsErrorSpanForSemanticError()
        {
            var buffer = new FakeTextBuffer("<#@ include file=\" \" #>");
            var tagger = new TemplateErrorTagger(buffer);

            var snapshotSpans             = new NormalizedSnapshotSpanCollection(new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length));
            ITagSpan <ErrorTag> errorSpan = tagger.GetTags(snapshotSpans).Single();

            Assert.Equal(new Span(12, 8), errorSpan.Span);
            Assert.Contains("File", (string)errorSpan.Tag.ToolTipContent, StringComparison.OrdinalIgnoreCase);
        }
        public IEnumerable <ITagSpan <IErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
        {
            var result = GetErrorTag(spans);

            if (result != null)
            {
                _tagSpan = result;
            }

            return(result != null ? new[] { result } : Array.Empty <ITagSpan <IErrorTag> >());
        }
Exemple #19
0
 private void ParseAndCache()
 {
     if (!Invalidated)
     {
         lock (Timer)
             Timer.Change(-1, -1);
         return;
     }
     try
     {
         Invalidated = false;
         var  snapshot = Buffer.CurrentSnapshot;
         bool validDsl;
         var  tokens            = SyntaxParser.GetTokens(snapshot, out validDsl);
         var  arr               = new ITagSpan <DddTokenTag> [tokens.Length];
         int  previousLine      = -1;
         ITextSnapshotLine line = null;
         for (int i = 0; i < tokens.Length; i++)
         {
             var d = tokens[i];
             var t = d.Concept;
             if (t.Line != previousLine)
             {
                 line         = snapshot.GetLineFromLineNumber(t.Line - 1);
                 previousLine = t.Line;
             }
             var span = new SnapshotSpan(snapshot, new Span(line.Start.Position + t.Column, t.Value.Length));
             arr[i] = new TagSpan <DddTokenTag>(span, d);
         }
         if (!validDsl)
         {
             if (TagsEqual(Tags, arr))
             {
                 return;
             }
         }
         if (Invalidated)
         {
             return;
         }
         Tags = arr;
         TagsChanged(this, new SnapshotSpanEventArgs(new SnapshotSpan(snapshot, Span.FromBounds(0, snapshot.Length))));
         lock (Timer)
             Timer.Change(1000, -1);
     }
     catch
     {
         lock (Timer)
             Timer.Change(5000, -1);
     }
 }
Exemple #20
0
 private static bool IsMultilineStringOrComment(ITagSpan <ClassificationTag> token)
 {
     if (token.Tag.ClassificationType.Classification == "string" &&
         !(token.Span.GetText().StartsWith("'") || token.Span.GetText().StartsWith("\"")))
     {
         return(true);
     }
     if (token.Tag.ClassificationType.Classification == "comment" &&
         !(token.Span.GetText().StartsWith("//") || token.Span.GetText().StartsWith("/*")))
     {
         return(true);
     }
     return(false);
 }
Exemple #21
0
        public static void GetTagsReturnsOutliningRegionsSpanWithCollapsedHintFormShowingEllipsisAfter10Lines()
        {
            string codeBlock = "<#" + Environment.NewLine;

            for (int i = 1; i <= 10; i++)
            {
                codeBlock += "Line" + i + Environment.NewLine;
            }

            codeBlock += "#>";

            ITagSpan <OutliningRegionTag> outliningSpan = GetTags(codeBlock).Single();

            var expectedHint = string.Join(
                Environment.NewLine,
                codeBlock.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Take(10).Concat(new[] { "..." }));

            Assert.Equal(expectedHint, outliningSpan.Tag.CollapsedHintForm);
        }
Exemple #22
0
        private void OnNewSearch(StartNewSearchEvent e)
        {
            if (!_textView.HasAggregateFocus || _textView.IsClosed)
            {
                return;
            }
            _searchMarkerViewModel.Update(e.Text, _textView.LineHeight, e.MatchNumber);
            if (_searcher != null)
            {
                return;
            }

            _searcher =
                new TagSpan <IntraTextAdornmentTag>(
                    span: new SnapshotSpan(_buffer.CurrentSnapshot, new Span(e.StartPosition, 0)),
                    tag: new IntraTextAdornmentTag(new SearcherWithMarker(_searchMarkerViewModel), null, PositionAffinity.Predecessor)
                    );
            _taggers.Add(0, _searcher);

            this.InvokeTagsChanged(TagsChanged, _buffer);
        }
            private void AddOutliningTagToAttribute(AttributeListSyntax attributeListNode)
            {
                if (AcuminatorVSPackage.Instance?.UseBqlOutlining != true || attributeListNode.Attributes.Count > 1)
                {
                    return;
                }

                AttributeSyntax attribute = attributeListNode.ChildNodes()
                                            .OfType <AttributeSyntax>()
                                            .FirstOrDefault();

                if (attribute?.ArgumentList == null || attribute.ArgumentList.Arguments.Count == 0 || _cancellationToken.IsCancellationRequested)
                {
                    return;
                }

                string collapsedText = GetAttributeName(attribute);
                ITagSpan <IOutliningRegionTag> tag = attributeListNode.Span.ToOutliningTagSpan(_tagger.Snapshot, collapsedText);

                _tagger.OutliningsTagsCache.AddTag(tag);
            }
        private void HandleErrorChanged(object sender, EventArgs e)
        {
            if (_tagSpan != null)
            {
                TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(_tagSpan.Span));
                _tagSpan = null;
            }

            _error = _process.Error;

            if (_sink != null)
            {
                if (_error != null)
                {
                    _sink.AddEntries(new[] { new XamlErrorTableEntry(_projectName, _path, _error) }, true);
                }
                else
                {
                    _sink.RemoveAllEntries();
                }
            }

            RaiseTagsChanged(_error);
        }
Exemple #25
0
 public TagNode(ITagSpan <TTag> ts, SpanTrackingMode trackingMode)
 {
     _snapshotSpan = ts.Span;
     this.Span     = ts.Span.CreateTrackingSpan(trackingMode);
     this.Tag      = ts.Tag;
 }
Exemple #26
0
 public int GetHashCode(ITagSpan <TTag> obj)
 {
     return(obj.Span.GetHashCode() ^ _tagComparer.GetHashCode(obj.Tag));
 }
Exemple #27
0
 public void AddTag(ITagSpan <TTag> tag)
 {
     tagSpans.Add(tag);
 }
Exemple #28
0
 private bool IsSameTag(IClassificationTag c1, ITagSpan <IClassificationTag> c2)
 {
     return(c1.ClassificationType.Classification == c2.Tag.ClassificationType.Classification);
 }
        void RemoveNavigateToTagSpan() {

            if (_navigateToTagSpan == null) {
                return;
            }

            UnderlineTagger.GetOrCreateSingelton(_textView.TextBuffer)?.RemoveUnderlineSpan(_navigateToTagSpan.Span);
            _navigateToTagSpan = null;

            _textView.VisualElement.Cursor = _overriddenCursor;
        }
Exemple #30
0
 public TagWrapper(ITagSpan <TTag> tag)
 {
     this.Span = tag.Span.Span;
     this.Tag  = new Optional <ITagSpan <TTag> >(tag);
 }
Exemple #31
0
 private bool AreAdjacent(SnapshotSpan c1, ITagSpan <IClassificationTag> c2)
 {
     return(c1.End == c2.Span.Start);
 }
        void UpdateNavigateToTagSpan(ITagSpan<GoToTag> navigateToTagSpan) {

            if(navigateToTagSpan.Span == _navigateToTagSpan?.Span) {
                // Theoretisch könnten sich die Tags dennoch unterscheiden...
                _navigateToTagSpan = navigateToTagSpan;
                return;
            }

            RemoveNavigateToTagSpan();

            _navigateToTagSpan = navigateToTagSpan;
            UnderlineTagger.GetOrCreateSingelton(_textView.TextBuffer)?.AddUnderlineSpan(navigateToTagSpan.Span);

            _overriddenCursor = _textView.VisualElement.Cursor;
            _textView.VisualElement.Cursor = Cursors.Hand;
        }
 public bool Equals(ITagSpan <TTag> tagSpan1, ITagSpan <TTag> tagSpan2)
 {
     return(_comparer.Equals(tagSpan1.Tag, tagSpan2.Tag));
 }
 private static bool IsUrlSpanValid(ITagSpan<IUrlTag> urlTagSpan)
 {
     return urlTagSpan != null
         && urlTagSpan.Tag != null
         && urlTagSpan.Tag.Url != null
         && urlTagSpan.Tag.Url.IsAbsoluteUri;
 }
        private bool TryGetUrlSpan(int line, int column, out ITagSpan<IUrlTag> urlSpan)
        {
            urlSpan = null;

            SnapshotPoint point;
            if (!TryToSnapshotPoint(TextView.TextSnapshot, line, column, out point))
                return false;

            SnapshotSpan span = new SnapshotSpan(point, 0);
            foreach (IMappingTagSpan<IUrlTag> current in _urlTagAggregator.GetTags(span))
            {
                NormalizedSnapshotSpanCollection spans = current.Span.GetSpans(TextView.TextSnapshot);
                if (spans.Count == 1 && spans[0].Length == current.Span.GetSpans(current.Span.AnchorBuffer)[0].Length && spans[0].Contains(span.Start))
                {
                    urlSpan = new TagSpan<IUrlTag>(spans[0], current.Tag);
                    return true;
                }
            }

            return false;
        }
        bool GoToDiagnostic(ITagSpan<DiagnosticErrorTag> tagSpan) {
            if (tagSpan == null) {
                return false;
            }

            _outliningManager.ExpandAll(tagSpan.Span, c => c.IsCollapsed);

            _textView.Caret.MoveTo(tagSpan.Span.Start);
            _textView.ViewScroller.EnsureSpanVisible(tagSpan.Span);
            
            return true;
        }
 void AddNavigateToTagSpan(ITagSpan<GoToDefinitionTag> navigateToTagSpan) {
     GoToDefinitionAdorner.GetOrCreate(_textView)?.SetNavigateToSpan(navigateToTagSpan.Span, () => NavigateTo(navigateToTagSpan));
 }
Exemple #38
0
        private bool IsCloseGrouping(ITagSpan<ClassificationTag> token) {
            var text = token.Span.GetText();

            return text == ")" || text == "}" || text == "]";
        }
Exemple #39
0
        private bool IsOpenGrouping(ITagSpan<ClassificationTag> token) {
            var text = token.Span.GetText();

            return text == "(" || text == "{" || text == "[";
        }
Exemple #40
0
 private static bool IsMultilineStringOrComment(ITagSpan<ClassificationTag> token) {
     if (token.Tag.ClassificationType.Classification == "string" &&
         !(token.Span.GetText().StartsWith("'") || token.Span.GetText().StartsWith("\""))) {
         return true;
     }
     if (token.Tag.ClassificationType.Classification == "comment" &&
         !(token.Span.GetText().StartsWith("//") || token.Span.GetText().StartsWith("/*"))) {
         return true;
     }
     return false;
 }