Allow multiple class callouts in one line

Author: reakaleek

src/Elastic.Markdown/Myst/CodeBlocks/EnhancedCodeBlock.cs

@@ -20,7 +20,7 @@ public class EnhancedCodeBlock(BlockParser parser, ParserContext context)
 
 	public int OpeningLength => Info?.Length ?? 0 + 3;
 
-	public List<CallOut>? CallOuts { get; set; }
+	public List<CallOut> CallOuts { get; set; } = [];
 
 	public IReadOnlyCollection<CallOut> UniqueCallOuts => CallOuts?.DistinctBy(c => c.Index).ToList() ?? [];
 

src/Elastic.Markdown/Myst/CodeBlocks/EnhancedCodeBlockHtmlRenderer.cs

@@ -55,7 +55,7 @@ private static void RenderCallouts(HtmlRenderer renderer, EnhancedCodeBlock bloc
 	{
 		var callOuts = FindCallouts(block.CallOuts ?? [], lineNumber + 1);
 		foreach (var callOut in callOuts)
-			renderer.Write($"<span class=\"code-callout\">{callOut.Index}</span>");
+			renderer.Write($"<span class=\"code-callout\" data-index=\"{callOut.Index}\">{callOut.Index}</span>");
 	}
 
 	private static IEnumerable<CallOut> FindCallouts(

src/Elastic.Markdown/Myst/CodeBlocks/EnhancedCodeBlockParser.cs

@@ -98,43 +98,36 @@ public override bool Close(BlockProcessor processor, Block block)
 			if (codeBlock.OpeningFencedCharCount > 3)
 				continue;
 
-			if (span.IndexOf("<") < 0 && span.IndexOf("//") < 0)
-				continue;
-
-			CallOut? callOut = null;
-
-			if (span.IndexOf("<") > 0)
+			List<CallOut> callOuts = [];
+			var hasClassicCallout = span.IndexOf("<") > 0;
+			if (hasClassicCallout)
 			{
 				var matchClassicCallout = CallOutParser.CallOutNumber().EnumerateMatches(span);
-				callOut = EnumerateAnnotations(matchClassicCallout, ref span, ref callOutIndex, originatingLine, false);
-			}
-
-			// only support magic callouts for smaller line lengths
-			if (callOut is null && span.Length < 200)
+				callOuts.AddRange(
+					EnumerateAnnotations(matchClassicCallout, ref span, ref callOutIndex, originatingLine, false)
+				);
+			} else if (span.Length < 200)
 			{
 				var matchInline = CallOutParser.MathInlineAnnotation().EnumerateMatches(span);
-				callOut = EnumerateAnnotations(matchInline, ref span, ref callOutIndex, originatingLine,
-					true);
+				callOuts.AddRange(
+					EnumerateAnnotations(matchInline, ref span, ref callOutIndex, originatingLine, true)
+				);
 			}
-
-			if (callOut is null)
-				continue;
-
-			codeBlock.CallOuts ??= [];
-			codeBlock.CallOuts.Add(callOut);
+			codeBlock.CallOuts.AddRange(callOuts);
 		}
 
 		//update string slices to ignore call outs
-		if (codeBlock.CallOuts is not null)
+		if (codeBlock.CallOuts?.Count > 0)
 		{
-			foreach (var callout in codeBlock.CallOuts)
+			foreach (var calloutLine in codeBlock.CallOuts.Select(c => c.Line).Distinct())
 			{
-				var line = lines.Lines[callout.Line - 1];
-
-				var newSpan = line.Slice.AsSpan()[..callout.SliceStart];
+				var line = lines.Lines[calloutLine - 1];
+				var index = Math.Max(line.Slice.AsSpan().IndexOf("//"), line.Slice.AsSpan().IndexOf('#'));
+				if (index < 0)
+					continue;
+				var newSpan = line.Slice.AsSpan()[..(index)];
 				var s = new StringSlice(newSpan.ToString());
-				lines.Lines[callout.Line - 1] = new StringLine(ref s);
-
+				lines.Lines[calloutLine - 1] = new StringLine(ref s);
 			}
 		}
 
@@ -149,44 +142,83 @@ public override bool Close(BlockProcessor processor, Block block)
 		return base.Close(processor, block);
 	}
 
-	private static CallOut? EnumerateAnnotations(Regex.ValueMatchEnumerator matches,
+	private static List<CallOut> EnumerateAnnotations(Regex.ValueMatchEnumerator matches,
 		ref ReadOnlySpan<char> span,
 		ref int callOutIndex,
 		int originatingLine,
 		bool inlineCodeAnnotation)
 	{
+		var callOuts = new List<CallOut>();
 		foreach (var match in matches)
 		{
 			if (match.Length == 0)
 				continue;
 
-			var startIndex = span.LastIndexOf("<");
-			if (!inlineCodeAnnotation && startIndex <= 0)
-				continue;
 			if (inlineCodeAnnotation)
 			{
-				startIndex = Math.Max(span.LastIndexOf("//"), span.LastIndexOf('#'));
-				if (startIndex <= 0)
-					continue;
+				var callOut = ParseMagicCallout(match, ref span, ref callOutIndex, originatingLine);
+				if (callOut != null)
+					return [callOut];
+				continue;
 			}
 
-			callOutIndex++;
-			var callout = span.Slice(match.Index + startIndex, match.Length - startIndex);
-			var index = callOutIndex;
-			if (!inlineCodeAnnotation && int.TryParse(callout.Trim(['<', '>']), out index))
-			{
+			var classicCallOuts = ParseClassicCallOuts(match, ref span, ref callOutIndex, originatingLine);
+			callOuts.AddRange(classicCallOuts);
+		}
 
-			}
-			return new CallOut
+		return callOuts;
+	}
+
+	private static CallOut? ParseMagicCallout(ValueMatch match, ref ReadOnlySpan<char> span, ref int callOutIndex, int originatingLine)
+	{
+		var startIndex = Math.Max(span.LastIndexOf("//"), span.LastIndexOf('#'));
+		if (startIndex <= 0)
+			return null;
+
+		callOutIndex++;
+		var callout = span.Slice(match.Index + startIndex, match.Length - startIndex);
+
+		return new CallOut
+		{
+			Index = callOutIndex,
+			Text = callout.TrimStart('/').TrimStart('#').TrimStart().ToString(),
+			InlineCodeAnnotation = true,
+			SliceStart = startIndex,
+			Line = originatingLine,
+		};
+	}
+
+	private static List<CallOut> ParseClassicCallOuts(ValueMatch match, ref ReadOnlySpan<char> span, ref int callOutIndex, int originatingLine)
+	{
+		var startIndex = span.LastIndexOf("<");
+		if (startIndex <= 0)
+			return [];
+
+		callOutIndex++;
+
+		var allStartIndices = new List<int>();
+		for (var i = 0; i < span.Length; i++)
+		{
+			if (span[i] == '<')
+				allStartIndices.Add(i);
+		}
+
+		var callOuts = new List<CallOut>();
+		foreach (var individualStartIndex in allStartIndices)
+		{
+			var endIndex = span.Slice(match.Index + individualStartIndex).IndexOf('>') + 1;
+			var callout = span.Slice(match.Index + individualStartIndex, endIndex);
+			_ = int.TryParse(callout.Trim(['<', '>']), out var index);
+			callOuts.Add(new CallOut
 			{
 				Index = index,
 				Text = callout.TrimStart('/').TrimStart('#').TrimStart().ToString(),
-				InlineCodeAnnotation = inlineCodeAnnotation,
-				SliceStart = startIndex,
+				InlineCodeAnnotation = false,
+				SliceStart = individualStartIndex,
 				Line = originatingLine,
-			};
+			});
 		}
 
-		return null;
+		return callOuts;
 	}
 }

src/Elastic.Markdown/_static/copybutton.js

@@ -153,15 +153,14 @@ function escapeRegExp(string) {
  * Removes excluded text from a Node.
  *
  * @param {Node} target Node to filter.
- * @param {string} exclude CSS selector of nodes to exclude.
+ * @param {string[]} excludes CSS selector of nodes to exclude.
  * @returns {DOMString} Text from `target` with text removed.
  */
-function filterText(target, exclude) {
+function filterText(target, excludes) {
     const clone = target.cloneNode(true);  // clone as to not modify the live DOM
-    if (exclude) {
-        // remove excluded nodes
-        clone.querySelectorAll(exclude).forEach(node => node.remove());
-    }
+    excludes.forEach(exclude => {
+      clone.querySelectorAll(excludes).forEach(node => node.remove());
+    })
     return clone.innerText;
 }
 
@@ -222,11 +221,9 @@ function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onl
 
 var copyTargetText = (trigger) => {
   var target = document.querySelector(trigger.attributes['data-clipboard-target'].value);
-
   // get filtered text
-  let exclude = '.linenos';
-
-  let text = filterText(target, exclude);
+  let excludes = ['.code-callout', '.linenos'];
+  let text = filterText(target, excludes);
   return formatCopyText(text, '', false, true, true, true, '', '')
 }
 

src/Elastic.Markdown/_static/custom.css

@@ -150,6 +150,15 @@ See https://github.com/elastic/docs-builder/issues/219 for further details
 	justify-content: center;
 	margin: 0;
 	transform: translateY(-2px);
+	user-select: none; /* Standard */
+	-webkit-user-select: none; /* Safari */
+	-moz-user-select: none; /* Firefox */
+	-ms-user-select: none; /* IE10+/Edge */
+	user-select: none; /* Standard */
+}
+
+.yue code span.code-callout:not(:last-child) {
+	margin-right: 5px;
 }
 
 .yue code span.code-callout > span {

tests/Elastic.Markdown.Tests/CodeBlocks/CallOutTests.cs

@@ -168,3 +168,25 @@ public void ParsesMagicCallOuts() => Block!.CallOuts
 	[Fact]
 	public void HasNoErrors() => Collector.Diagnostics.Should().HaveCount(0);
 }
+
+public class MultipleCalloutsInOneLine(ITestOutputHelper output) : CodeBlockCallOutTests(output, "csharp",
+	"""
+	var x = 1; <1>
+	var y = x - 2;
+	var z = y - 2; <1> <2>
+	""",
+	"""
+	1. First callout
+	2. Second callout
+	"""
+)
+{
+	[Fact]
+	public void ParsesMagicCallOuts() => Block!.CallOuts
+		.Should().NotBeNullOrEmpty()
+		.And.HaveCount(3)
+		.And.OnlyContain(c => c.Text.StartsWith("<"));
+
+	[Fact]
+	public void HasNoErrors() => Collector.Diagnostics.Should().HaveCount(0);
+}