mirror of
https://github.com/nesquena/hermes-webui.git
synced 2026-05-24 18:50:15 +00:00
nesquena-hermes
f6ea11d22e
Root cause: the old rule `s.replace(/^> (.+)$/gm, ...)` had three bugs:
1. `.+` required at least one character — bare `>` lines (blank
continuation lines) did not match and passed through as literal `>`
2. Each matching line became its own `<blockquote>` element — a 10-line
blockquote produced 10 stacked `<blockquote>` tags with no grouping
3. When a fenced code block sat inside a blockquote, the fence-stash
pass consumed the code content and left orphaned `>` lines that the
old `.+` pattern could not match
Fix: replace the single-line regex with a group-based approach that matches
one or more consecutive `>` lines as a single block, strips the `>` prefix
from each line, passes each non-empty line through inlineMd(), turns blank
`>` lines into `<br>`, and wraps the entire group in one `<blockquote>`.
14 regression tests added covering:
- Single-line blockquotes (regression)
- Multi-line grouping (2 and 10 lines)
- Two separate blockquotes staying separate
- Bare `>` and `>text` (no space) edge cases
- Blank continuation lines → <br>
- Bold / italic / inline-code inside blockquotes
- Blockquote followed by normal paragraph
176 lines
6.8 KiB
Python
176 lines
6.8 KiB
Python
"""Regression tests for the blockquote rendering fix (fix/blockquote-rendering).
|
|
|
|
Root cause: the old rule was `s.replace(/^> (.+)$/gm, ...)` which had three bugs:
|
|
1. `.+` required at least one character — bare `>` lines passed through as literal `>`
|
|
2. Each line became its own `<blockquote>` — no grouping, so 10-line quotes became
|
|
10 stacked `<blockquote>` elements
|
|
3. Fenced code blocks inside blockquotes left orphaned `>` literals after the
|
|
fence-stash pass had consumed the code content
|
|
|
|
Fix: group consecutive `>` lines into a single `<blockquote>`, handle bare `>` lines
|
|
as `<br>`, and strip the `>` prefix before passing each line to `inlineMd()`.
|
|
"""
|
|
import re
|
|
import pathlib
|
|
|
|
UI_JS = (pathlib.Path(__file__).parent.parent / "static" / "ui.js").read_text(encoding="utf-8")
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Python mirror of the new blockquote rule + inlineMd (for behavioural tests)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
import html as _html
|
|
|
|
|
|
def _esc(s):
|
|
return _html.escape(str(s), quote=True)
|
|
|
|
|
|
def _inline_md(t):
|
|
"""Minimal inlineMd mirror — bold, italic, inline-code only."""
|
|
t = re.sub(r"`([^`\n]+)`", lambda m: f"<code>{_esc(m.group(1))}</code>", t)
|
|
t = re.sub(r"\*\*\*(.+?)\*\*\*", lambda m: f"<strong><em>{_esc(m.group(1))}</em></strong>", t)
|
|
t = re.sub(r"\*\*(.+?)\*\*", lambda m: f"<strong>{_esc(m.group(1))}</strong>", t)
|
|
t = re.sub(r"\*([^*\n]+)\*", lambda m: f"<em>{_esc(m.group(1))}</em>", t)
|
|
return t
|
|
|
|
|
|
def _apply_blockquote(s):
|
|
"""Python mirror of the new group-based blockquote rule in ui.js."""
|
|
def replacer(m):
|
|
block = m.group(0)
|
|
lines = block.split("\n")
|
|
# Drop a lone trailing ">" artifact that the regex can leave
|
|
while lines and lines[-1].strip() in (">", ""):
|
|
if lines[-1].strip() == ">":
|
|
lines.pop()
|
|
break
|
|
lines.pop()
|
|
processed = []
|
|
for l in lines:
|
|
stripped = re.sub(r"^>[ \t]?", "", l)
|
|
if stripped.strip() == "":
|
|
processed.append("<br>")
|
|
else:
|
|
processed.append(_inline_md(stripped))
|
|
inner = "\n".join(processed)
|
|
return f"<blockquote>{inner}</blockquote>"
|
|
|
|
return re.sub(r"((?:^>[^\n]*(?:\n|$))+)", replacer, s, flags=re.MULTILINE)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Source-level structural tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestBlockquoteSourceStructure:
|
|
"""The new rule must be present in ui.js and the old single-line rule must be gone."""
|
|
|
|
def test_old_single_line_rule_removed(self):
|
|
"""The old `.+` pattern that skipped blank lines must be gone."""
|
|
assert "replace(/^> (.+)$/gm" not in UI_JS, (
|
|
"Old single-line blockquote rule still present — it misses blank '>'"
|
|
" lines and creates one <blockquote> per line"
|
|
)
|
|
|
|
def test_new_group_rule_present(self):
|
|
"""The new grouping regex must be present."""
|
|
assert "(?:^>[^\\n]*(?:\\n|$))+" in UI_JS, (
|
|
"New group-based blockquote rule not found in ui.js"
|
|
)
|
|
|
|
def test_prefix_strip_present(self):
|
|
"""The fix must strip the '> ' prefix from each line."""
|
|
assert "replace(/^>[" in UI_JS or "replace(/^>[ " in UI_JS, (
|
|
"Expected prefix-strip pattern not found in the blockquote block"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Behavioural tests (using the Python mirror)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestMultiLineBlockquote:
|
|
"""Consecutive > lines must become ONE <blockquote>, not many."""
|
|
|
|
def test_single_line_still_works(self):
|
|
out = _apply_blockquote("> Hello world")
|
|
assert out.count("<blockquote>") == 1
|
|
assert "Hello world" in out
|
|
assert ">" not in out.replace("<blockquote>", "").replace("</blockquote>", "")
|
|
|
|
def test_two_consecutive_lines_grouped(self):
|
|
src = "> Line one\n> Line two"
|
|
out = _apply_blockquote(src)
|
|
assert out.count("<blockquote>") == 1, (
|
|
f"Expected 1 <blockquote>, got {out.count('<blockquote>')}: {out!r}"
|
|
)
|
|
|
|
def test_ten_lines_one_blockquote(self):
|
|
src = "\n".join(f"> Line {i}" for i in range(10))
|
|
out = _apply_blockquote(src)
|
|
assert out.count("<blockquote>") == 1
|
|
|
|
def test_two_separate_quotes_stay_separate(self):
|
|
src = "> First quote\n\n> Second quote"
|
|
out = _apply_blockquote(src)
|
|
# Each quote is its own group (separated by a blank line)
|
|
assert out.count("<blockquote>") == 2
|
|
|
|
|
|
class TestBlankContinuationLines:
|
|
"""Bare '>' lines (blank continuation) must not appear as literal '>'."""
|
|
|
|
def test_bare_gt_line_no_literal(self):
|
|
src = "> Para one\n>\n> Para two"
|
|
out = _apply_blockquote(src)
|
|
assert out.count("<blockquote>") == 1, f"Expected 1 blockquote: {out!r}"
|
|
# No stray '>' outside of HTML tags
|
|
text_only = re.sub(r"<[^>]+>", "", out)
|
|
assert ">" not in text_only, f"Literal '>' in text: {text_only!r}"
|
|
|
|
def test_bare_gt_no_space_handled(self):
|
|
"""'>' with no space at all should also be consumed, not rendered literally."""
|
|
src = ">no space after"
|
|
out = _apply_blockquote(src)
|
|
assert out.count("<blockquote>") == 1
|
|
text_only = re.sub(r"<[^>]+>", "", out)
|
|
assert ">" not in text_only
|
|
|
|
def test_blank_line_becomes_br(self):
|
|
src = "> First\n>\n> Second"
|
|
out = _apply_blockquote(src)
|
|
assert "<br>" in out, f"Expected <br> for blank > line: {out!r}"
|
|
|
|
|
|
class TestInlineMarkdownInsideBlockquote:
|
|
"""Bold, italic, and inline code must still render correctly inside a blockquote."""
|
|
|
|
def test_bold_inside_blockquote(self):
|
|
out = _apply_blockquote("> This is **important**")
|
|
assert "<strong>" in out
|
|
assert "<blockquote>" in out
|
|
|
|
def test_inline_code_inside_blockquote(self):
|
|
out = _apply_blockquote("> Run `git status` first")
|
|
assert "<code>" in out
|
|
assert "<blockquote>" in out
|
|
|
|
def test_italic_inside_blockquote(self):
|
|
out = _apply_blockquote("> *emphasis* here")
|
|
assert "<em>" in out
|
|
assert "<blockquote>" in out
|
|
|
|
|
|
class TestBlockquoteFollowedByParagraph:
|
|
"""A blockquote followed by a normal paragraph must not bleed into each other."""
|
|
|
|
def test_non_blockquote_paragraph_untouched(self):
|
|
src = "> Quoted text\n\nNormal paragraph"
|
|
out = _apply_blockquote(src)
|
|
assert out.count("<blockquote>") == 1
|
|
assert "Normal paragraph" in out
|
|
# Normal paragraph must be outside the blockquote
|
|
after_bq = out[out.index("</blockquote>"):]
|
|
assert "Normal paragraph" in after_bq
|