links-notation 0.28.0__tar.gz → 0.30.0__tar.gz

{links_notation-0.28.0/links_notation.egg-info → links_notation-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: links-notation
-Version: 0.28.0
+Version: 0.30.0
 Summary: Python implementation of the Links Notation parser
 Author-email: "Link.Foundation" <drakonard@gmail.com>
 License-Expression: Unlicense
@@ -22,12 +22,12 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
-Requires-Dist: pytest>=9.1.1; extra == "test"
+Requires-Dist: pytest>=9.2.0; extra == "test"
 Requires-Dist: pytest-timeout>=2.4.0; extra == "test"
 Provides-Extra: lint
 Requires-Dist: black>=26.10.1; extra == "lint"
 Requires-Dist: isort>=9.0.2; extra == "lint"
-Requires-Dist: flake8>=7.4.1; extra == "lint"
+Requires-Dist: flake8>=7.5.0; extra == "lint"
 Provides-Extra: dev
 Requires-Dist: links-notation[lint,test]; extra == "dev"
 Dynamic: license-file

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation/comments.py

@@ -13,12 +13,15 @@ still points at what the reader can see.
 """
 
 from .quotes import QUOTE_CHARS, _parse_quoted_string_at
+from .reference_literal import reference_literal_end
 
 #: The character that starts a comment.
 COMMENT = "#"
 
-#: What a delimited reference may start after.
-BEFORE_REFERENCE = (" ", "\t", "\n", "\r", "(", ":")
+#: What ends a token, so that what follows it starts a new one. A delimited
+#: reference or a literal may start at the start of any token, and also right
+#: after a delimited reference or a literal, as the parser reads them.
+SEPARATORS = (" ", "\t", "\n", "\r", "(", ":", ")")
 
 #: What a comment may start after.
 BEFORE_COMMENT = (" ", "\t", "\n", "\r")
@@ -28,7 +31,9 @@ def strip_comments(document: str) -> str:
     """
     Return ``document`` with every comment blanked out.
 
-    The result has the same length as the document it was given.
+    The result has the same length as the document it was given. Tokens are
+    read as the parser reads them, so a ``#`` inside a delimited reference that
+    follows a group, another reference or a literal stays content (issue #377).
 
     >>> strip_comments("a: b # why\\n")
     'a: b      \\n'
@@ -36,18 +41,16 @@ def strip_comments(document: str) -> str:
     '"# kept"\\n'
     >>> strip_comments("issue#1047\\n")
     'issue#1047\\n'
+    >>> strip_comments('(a)" #b"\\n')
+    '(a)" #b"\\n'
     """
     blanked = None
     position = 0
+    token_start = True
 
     while position < len(document):
         char = document[position]
 
-        if char in QUOTE_CHARS and _follows(document, position, BEFORE_REFERENCE):
-            parsed = _parse_quoted_string_at(document, position)
-            position = position + 1 if parsed is None else parsed[1]
-            continue
-
         if char == COMMENT and _follows(document, position, BEFORE_COMMENT):
             if blanked is None:
                 blanked = list(document)
@@ -56,11 +59,39 @@ def strip_comments(document: str) -> str:
                 position += 1
             continue
 
+        if char in SEPARATORS:
+            token_start = True
+            position += 1
+            continue
+
+        if token_start:
+            end = delimited_token_end(document, position)
+            if end is not None:
+                position = end
+                continue
+
+        token_start = False
         position += 1
 
     return document if blanked is None else "".join(blanked)
 
 
+def delimited_token_end(document: str, start: int):
+    """
+    Where the versioned literal or delimited reference that starts at ``start``
+    ends, or None when neither can be read there. What follows one starts a new
+    token.
+    """
+    literal = reference_literal_end(document, start)
+    if literal != -1:
+        return literal
+    if document[start] in QUOTE_CHARS:
+        parsed = _parse_quoted_string_at(document, start)
+        if parsed is not None:
+            return parsed[1]
+    return None
+
+
 def _follows(document: str, position: int, allowed) -> bool:
     """
     Report whether the character before ``position`` is one of ``allowed``, the

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation/cst.py

@@ -21,7 +21,7 @@ from typing import List, Optional, Tuple
 from .comments import strip_comments
 from .parser import ParseError
 from .quotes import QUOTE_CHARS, _parse_quoted_string_at
-from .reference_literal import decode_reference_literal
+from .reference_literal import decode_reference_literal, reference_literal_end
 
 
 class CstKind:
@@ -55,9 +55,6 @@ _NODE_KINDS = frozenset((CstKind.DOCUMENT, CstKind.LINE, CstKind.GROUP))
 _ESCAPES = {"\\": "\\\\", '"': '\\"', "\n": "\\n", "\r": "\\r", "\t": "\\t"}
 _ESCAPED = re.compile(r'[\\"\n\r\t]')
 
-#: A versioned literal.
-_LITERAL = re.compile(r"~[0-9]+\{[^} \t\r\n()]*\}")
-
 #: What ends a bare reference.
 _BARE_REFERENCE_END = frozenset(" \t\r\n(:)")
 
@@ -170,8 +167,11 @@ def build_cst(input_text: str, comments: bool = True) -> CstNode:
     Raises:
         ParseError: If the parentheses are unbalanced
     """
-    # References are read in the document the parser reads: the one with its
-    # comments blanked, which keeps every position of the one written.
+    # Bare references end where they end in the document the parser reads: the
+    # one with its comments blanked, which keeps every position of the one
+    # written. Delimited references and literals are read, as the parser reads
+    # them, in the document as written, so a comment never changes what a
+    # reference holds (issue #377).
     prepared = strip_comments(input_text) if comments else input_text
     document = CstNode(CstKind.DOCUMENT)
     # The open containers, innermost last.
@@ -232,14 +232,12 @@ def _reference(input_text: str, prepared: str, start: int) -> Tuple[CstNode, int
     The reference token that starts at ``start``, read as the parser reads it,
     and where it ends.
     """
-    if prepared[start] == "~":
-        literal = _LITERAL.match(prepared, start)
-        if literal is not None:
-            end = literal.end()
-            text = input_text[start:end]
-            return CstNode(CstKind.REFERENCE, text=text, value=decode_reference_literal(text)), end
-    if prepared[start] in QUOTE_CHARS:
-        quoted = _parse_quoted_string_at(prepared, start)
+    end = reference_literal_end(input_text, start)
+    if end != -1:
+        text = input_text[start:end]
+        return CstNode(CstKind.REFERENCE, text=text, value=decode_reference_literal(text)), end
+    if input_text[start] in QUOTE_CHARS:
+        quoted = _parse_quoted_string_at(input_text, start)
         if quoted is not None:
             value, end = quoted
             reference = CstNode(CstKind.REFERENCE, text=input_text[start:end], value=value, quote=input_text[start])

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation/parser.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 from .comments import strip_comments
 from .link import Link
 from .quotes import _parse_quoted_string_at
-from .reference_literal import decode_reference_literal
+from .reference_literal import decode_reference_literal, reference_literal_end
 
 if TYPE_CHECKING:
     from .cst import CstNode
@@ -274,14 +274,29 @@ class Parser:
         self.parse(input_text)
         return build_cst(input_text, comments=self.comments)
 
-    def _skip_quoted_string(self, text: str, start: int) -> int:
+    def _quoted_at(self, text: str, start: int, offset: int) -> Optional[tuple]:
         """
-        Skip over the quoted string starting at start.
+        Read the delimited reference at ``start`` in ``text``, a part of the
+        document that starts at ``offset``: ``(value, end)`` with ``end`` in
+        ``text``, or None.
+
+        The reference is read in the document as written, within the extent of
+        ``text``. ``text`` comes from the document with its comments blanked,
+        which keeps every position, and blanking a comment must not change what
+        a reference holds or how far it reaches (issue #377).
+        """
+        parsed = _parse_quoted_string_at(self.source, offset + start, offset + len(text))
+        return None if parsed is None else (parsed[0], parsed[1] - offset)
+
+    def _skip_quoted_string(self, text: str, start: int, offset: int) -> int:
+        """
+        Skip over the quoted string starting at start, ``text`` starting at
+        ``offset`` in the document.
 
         Returns the position right after the closing quotes, or -1 when text
         does not start a terminated quoted string.
         """
-        parsed = _parse_quoted_string_at(text, start)
+        parsed = self._quoted_at(text, start, offset)
         return -1 if parsed is None else parsed[1]
 
     def _split_lines_respecting_quotes(self, text: str, base: int) -> Tuple[List[str], List[int]]:
@@ -323,7 +338,7 @@ class Parser:
                 position = i + 1
             else:
                 # A quoted string is opaque: newlines inside it are content
-                end = self._skip_quoted_string(text, i)
+                end = self._skip_quoted_string(text, i, base)
                 position = end if end > i else i + 1
             counted = position
 
@@ -434,7 +449,7 @@ class Parser:
     def _parse_line_content(self, content: str, offset: int) -> Dict:
         """Parse the content of a single line, which starts at ``offset``."""
         # A whole parenthesized group: (id: values), (values) or a nested document
-        if content.startswith("(") and self._find_matching_paren(content, 0) == len(content) - 1:
+        if content.startswith("(") and self._find_matching_paren(content, 0, offset) == len(content) - 1:
             return self._parse_parenthesized(content[1:-1], offset)
 
         # Try indented ID syntax: id:
@@ -443,7 +458,7 @@ class Parser:
             return {"id": ref, "raw_id": raw, "values": [], "is_indented_id": True}
 
         # Try single-line link: id: values
-        colon_pos = self._find_colon_outside_quotes(content)
+        colon_pos = self._find_colon_outside_quotes(content, offset)
         if colon_pos >= 0:
             after_colon = content[colon_pos + 1 :]
             values_part = after_colon.strip()
@@ -496,9 +511,10 @@ class Parser:
             self.context_depth = saved_context_depth
             self.depth = saved_depth
 
-    def _find_matching_paren(self, text: str, start: int) -> int:
+    def _find_matching_paren(self, text: str, start: int, offset: int) -> int:
         """
-        Find the position of the parenthesis closing the one at start.
+        Find the position of the parenthesis closing the one at start, ``text``
+        starting at ``offset`` in the document.
 
         Quoted strings are skipped, so parentheses inside them are ignored.
         Returns -1 when the group is not closed, or when start is not at an
@@ -525,16 +541,17 @@ class Parser:
                         return run_start + depth - 1
                     depth -= run_end - run_start
                 else:
-                    end = self._skip_quoted_string(text, run_start)
+                    end = self._skip_quoted_string(text, run_start, offset)
                     if end > run_start:
                         position = end
                         break
             else:
                 return -1
 
-    def _find_colon_outside_quotes(self, text: str) -> int:
+    def _find_colon_outside_quotes(self, text: str, offset: int) -> int:
         """
-        Find the position of a colon that's not inside quotes or parentheses.
+        Find the position of a colon that's not inside quotes or parentheses,
+        ``text`` starting at ``offset`` in the document.
 
         This is crucial for correctly parsing nested self-referenced objects.
         For example, in: ((str key) (obj_1: dict ...))
@@ -558,7 +575,7 @@ class Parser:
                     return i
                 position = i + 1
             else:
-                end = self._skip_quoted_string(text, i)
+                end = self._skip_quoted_string(text, i, offset)
                 position = end if end > i else i + 1
             counted = position
 
@@ -578,7 +595,7 @@ class Parser:
                 break
 
             # Try to extract the next value
-            value_end, value_text = self._extract_next_value(text, i)
+            value_end, value_text = self._extract_next_value(text, i, offset)
             if value_text and value_text.strip():
                 values.append(self._parse_value(value_text, offset + i))
             if value_end == i:
@@ -589,9 +606,10 @@ class Parser:
 
         return values
 
-    def _extract_next_value(self, text: str, start: int) -> tuple:
+    def _extract_next_value(self, text: str, start: int, offset: int) -> tuple:
         """
-        Extract the next value from text starting at start position.
+        Extract the next value from text starting at start position, ``text``
+        starting at ``offset`` in the document.
         Returns (end_position, value_text).
         """
         if start >= len(text):
@@ -599,14 +617,20 @@ class Parser:
 
         # Check if this starts with a delimited reference (any N quotes, or a
         # bare delimiter pair standing for the empty reference)
-        quoted = _parse_quoted_string_at(text, start)
+        quoted = self._quoted_at(text, start, offset)
         if quoted is not None:
             _, end = quoted
             return (end, text[start:end])
 
+        # A versioned literal is a whole token: what follows it starts the
+        # next one, as the reference grammar (js/src/grammar.pegjs) reads it
+        literal = reference_literal_end(text, start)
+        if literal != -1:
+            return (literal, text[start:literal])
+
         # Check if this starts with a parenthesized expression
         if text[start] == "(":
-            end = self._find_matching_paren(text, start)
+            end = self._find_matching_paren(text, start, offset)
             if end >= 0:
                 return (end + 1, text[start : end + 1])
             return (len(text), text[start:])
@@ -625,44 +649,32 @@ class Parser:
     def _parse_value(self, value: str, offset: int) -> Dict:
         """Parse a single value (could be a reference or nested link) starting at ``offset``."""
         # Nested link in parentheses
-        if value.startswith("(") and self._find_matching_paren(value, 0) == len(value) - 1:
+        if value.startswith("(") and self._find_matching_paren(value, 0, offset) == len(value) - 1:
             return self._parse_parenthesized(value[1:-1], offset)
 
         # Simple reference
         ref, raw = self._read_reference(value, offset)
         return {"id": ref, "raw_id": raw}
 
-    def _extract_reference(self, text: str) -> str:
-        """Extract reference, handling quoted strings with escaping support."""
-        text = text.strip()
-
-        if re.match(r"~[0-9]+\{", text):
-            return decode_reference_literal(text)
-
-        # Try delimited references (any N quotes, or a bare delimiter pair)
-        quoted = _parse_quoted_string_at(text, 0)
-        if quoted is not None:
-            return quoted[0]
-
-        # Unquoted
-        return text
-
     def _read_reference(self, text: str, offset: int) -> Tuple[str, str]:
         """
         Read the reference ``text`` written at ``offset`` (surrounding
         whitespace allowed): what it means, and the text it was written as.
 
-        The text is sliced from the document as the caller wrote it, which has
-        the same positions as the one with its comments blanked out.
+        The reference is read in the document as the caller wrote it, which
+        has the same positions as the one with its comments blanked out.
         """
         reference = text.strip()
         start = offset + len(text) - len(text.lstrip())
         end = start + len(reference)
-        if not re.match(r"~[0-9]+\{", reference):
-            quoted = _parse_quoted_string_at(reference, 0)
-            if quoted is not None:
-                end = start + quoted[1]
-        return self._extract_reference(reference), self.source[start:end]
+        if re.match(r"~[0-9]+\{", reference):
+            return decode_reference_literal(reference), self.source[start:end]
+        # Delimited references (any N quotes, or a bare delimiter pair)
+        quoted = self._quoted_at(reference, 0, start)
+        if quoted is not None:
+            return quoted[0], self.source[start : start + quoted[1]]
+        # Unquoted
+        return reference, self.source[start:end]
 
     def _with_raw_id(self, link: Link, item: Dict) -> Link:
         """

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation/quotes.py

@@ -36,9 +36,10 @@ def _is_substantive_body(content: str) -> bool:
     return has_visible and depth == 0
 
 
-def _parse_quoted_string_at(text: str, start: int) -> Optional[tuple]:
+def _parse_quoted_string_at(text: str, start: int, stop: Optional[int] = None) -> Optional[tuple]:
     """
-    Parse the delimited reference that starts at ``start``.
+    Parse the delimited reference that starts at ``start``, reading no further
+    than ``stop`` (the end of ``text`` by default).
 
     Any number N of quotes opens and closes the string, 2*N quotes are an
     escaped quote sequence. A run of an even number of delimiters that does not
@@ -50,7 +51,8 @@ def _parse_quoted_string_at(text: str, start: int) -> Optional[tuple]:
     right after the closing quotes, or ``None`` when ``text`` does not start a
     delimited reference.
     """
-    if start >= len(text):
+    limit = len(text) if stop is None else stop
+    if start >= limit:
         return None
 
     quote_char = text[start]
@@ -59,7 +61,7 @@ def _parse_quoted_string_at(text: str, start: int) -> Optional[tuple]:
 
     quote_count = 0
     pos = start
-    while pos < len(text) and text[pos] == quote_char:
+    while pos < limit and text[pos] == quote_char:
         quote_count += 1
         pos += 1
 
@@ -70,14 +72,14 @@ def _parse_quoted_string_at(text: str, start: int) -> Optional[tuple]:
     escape_seq = quote_char * (quote_count * 2)
     content = []
 
-    while pos < len(text):
-        if text.startswith(escape_seq, pos):
+    while pos < limit:
+        if text.startswith(escape_seq, pos, limit):
             content.append(open_close)
             pos += len(escape_seq)
             continue
-        if text.startswith(open_close, pos):
+        if text.startswith(open_close, pos, limit):
             after_close = pos + quote_count
-            if after_close >= len(text) or text[after_close] != quote_char:
+            if after_close >= limit or text[after_close] != quote_char:
                 value = "".join(content)
                 if is_even_run and not _is_substantive_body(value):
                     return empty_reference
@@ -88,6 +90,29 @@ def _parse_quoted_string_at(text: str, start: int) -> Optional[tuple]:
     return empty_reference
 
 
+def _closing_run_follows(text: str, start: int) -> bool:
+    """
+    Report whether a run of delimiters after the one opening at ``start``
+    closes it. An even run nothing closes is the empty reference, until a
+    closing run is written after it.
+    """
+    quote_char = text[start]
+    count = 0
+    while start + count < len(text) and text[start + count] == quote_char:
+        count += 1
+    pos = start + count
+    while True:
+        pos = text.find(quote_char, pos)
+        if pos < 0:
+            return False
+        length = 0
+        while pos + length < len(text) and text[pos + length] == quote_char:
+            length += 1
+        if (length // count) % 2 == 1:
+            return True
+        pos += length
+
+
 def reference_quote(raw: Optional[str]) -> Optional[str]:
     """
     The delimiter a reference was written between, read from the reference as

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation/reference_literal.py

@@ -2,6 +2,15 @@
 
 import re
 
+#: A versioned literal ``~<digits>{<payload>}``, as the parser reads one.
+_LITERAL = re.compile(r"~[0-9]+\{[^} \t\r\n()]*\}")
+
+
+def reference_literal_end(text: str, start: int) -> int:
+    """Where the versioned literal that starts at ``start`` ends, or -1 if none starts there."""
+    match = _LITERAL.match(text, start)
+    return -1 if match is None else match.end()
+
 
 def encode_reference_literal(text: str) -> str:
     """Encode exact text as a versioned UTF-8 hexadecimal literal."""

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation/stream_parser.py

@@ -5,7 +5,8 @@ from typing import AsyncIterable, AsyncIterator, Callable, Iterable, Iterator, L
 
 from .link import Link
 from .parser import DEFAULT_MAX_DEPTH, ParseError, Parser
-from .quotes import QUOTE_CHARS, _parse_quoted_string_at
+from .quotes import QUOTE_CHARS, _closing_run_follows, _parse_quoted_string_at
+from .reference_literal import reference_literal_end
 
 
 @dataclass(frozen=True)
@@ -210,30 +211,47 @@ def _leading_spaces(line: str) -> int:
 
 
 def _structurally_complete(document: str, comments: bool) -> bool:
+    # Tokens are read as the comment reader and the parser read them: a
+    # reference may start after a separator, and right after a delimited
+    # reference or a literal (issue #377).
     depth = 0
     position = 0
-    before_reference = " \t\n\r(:"
+    token_start = True
+    separators = " \t\n\r(:)"
     before_comment = " \t\n\r"
 
     while position < len(document):
         character = document[position]
         previous = None if position == 0 else document[position - 1]
-        if character in QUOTE_CHARS and (previous is None or previous in before_reference):
-            parsed = _parse_quoted_string_at(document, position)
-            if parsed is None:
-                return False
-            position = parsed[1]
-            continue
         if comments and character == "#" and (previous is None or previous in before_comment):
             newline = document.find("\n", position)
             if newline < 0:
                 break
-            position = newline + 1
+            position = newline
+            continue
+        if character in separators:
+            if character == "(":
+                depth += 1
+            elif character == ")":
+                depth -= 1
+            token_start = True
+            position += 1
+            continue
+        if token_start and character in QUOTE_CHARS:
+            # A reference nothing closes yet may be closed by a later line,
+            # which changes what it holds: an even run is the empty reference
+            # only when no run in the whole document closes it.
+            parsed = _parse_quoted_string_at(document, position)
+            if parsed is None or not _closing_run_follows(document, position):
+                return False
+            position = parsed[1]
             continue
-        if character == "(":
-            depth += 1
-        elif character == ")":
-            depth -= 1
+        if token_start:
+            end = reference_literal_end(document, position)
+            if end != -1:
+                position = end
+                continue
+        token_start = False
         position += 1
 
     return depth == 0

{links_notation-0.28.0 → links_notation-0.30.0/links_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: links-notation
-Version: 0.28.0
+Version: 0.30.0
 Summary: Python implementation of the Links Notation parser
 Author-email: "Link.Foundation" <drakonard@gmail.com>
 License-Expression: Unlicense
@@ -22,12 +22,12 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
-Requires-Dist: pytest>=9.1.1; extra == "test"
+Requires-Dist: pytest>=9.2.0; extra == "test"
 Requires-Dist: pytest-timeout>=2.4.0; extra == "test"
 Provides-Extra: lint
 Requires-Dist: black>=26.10.1; extra == "lint"
 Requires-Dist: isort>=9.0.2; extra == "lint"
-Requires-Dist: flake8>=7.4.1; extra == "lint"
+Requires-Dist: flake8>=7.5.0; extra == "lint"
 Provides-Extra: dev
 Requires-Dist: links-notation[lint,test]; extra == "dev"
 Dynamic: license-file

{links_notation-0.28.0 → links_notation-0.30.0}/links_notation.egg-info/requires.txt

@@ -5,8 +5,8 @@ links-notation[lint,test]
 [lint]
 black>=26.10.1
 isort>=9.0.2
-flake8>=7.4.1
+flake8>=7.5.0
 
 [test]
-pytest>=9.1.1
+pytest>=9.2.0
 pytest-timeout>=2.4.0

{links_notation-0.28.0 → links_notation-0.30.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=84.0.0"]
+requires = ["setuptools>=84.2.1"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "links-notation"
-version = "0.28.0"
+version = "0.30.0"
 description = "Python implementation of the Links Notation parser"
 readme = "README.md"
 license = "Unlicense"
@@ -29,8 +29,8 @@ requires-python = ">=3.11"
 dependencies = []
 
 [project.optional-dependencies]
-test = ["pytest>=9.1.1", "pytest-timeout>=2.4.0"]
-lint = ["black>=26.10.1", "isort>=9.0.2", "flake8>=7.4.1"]
+test = ["pytest>=9.2.0", "pytest-timeout>=2.4.0"]
+lint = ["black>=26.10.1", "isort>=9.0.2", "flake8>=7.5.0"]
 dev = ["links-notation[test,lint]"]
 
 [project.urls]

{links_notation-0.28.0 → links_notation-0.30.0}/tests/test_comments.py

@@ -122,3 +122,32 @@ class TestFormattingAReferenceThatBeginsWithAHash:
         assert Link.escape_reference("issue#1047") == "issue#1047"
         assert Link.escape_reference("#") == "'#'"
         assert Link.escape_reference("#ff0000") == "'#ff0000'"
+
+
+class TestReferencesTheCommentReaderSkips:
+    """
+    Issue #377: the comment reader and the parser agree on where every
+    delimited reference starts and how far it reaches.
+    """
+
+    def test_a_hash_inside_a_reference_that_follows_a_group_is_content(self):
+        assert rendered('(a)" #b"\n') == "((<a>) < #b>)"
+
+    def test_a_hash_inside_a_reference_that_follows_another_reference_is_content(self):
+        assert rendered("\"x\"' #y'\n") == "(<x> < #y>)"
+        assert rendered('```q```"" #c\n"""\n') == '(<q> < #c\n">)'
+
+    def test_a_hash_inside_a_reference_that_follows_a_literal_is_content(self):
+        assert rendered('~1{62}" #b"\n') == "(<b> < #b>)"
+
+    def test_a_reference_is_read_in_the_document_as_written(self):
+        # The body of the first ``""`` straddles a parenthesis, so it is the
+        # empty reference and the ``#`` after it opens a comment. Blanking that
+        # comment must not turn the ``""`` into a reference holding the blanks.
+        assert rendered('"" a #)b\n""\n') == "(<> <a>)\n(<>)"
+
+    def test_the_comment_reader_skips_the_references_the_parser_reads(self):
+        assert strip_comments('(a)" #b"\n') == '(a)" #b"\n'
+        assert strip_comments("\"x\"' #y'\n") == "\"x\"' #y'\n"
+        assert strip_comments('~1{62}" #b"\n') == '~1{62}" #b"\n'
+        assert strip_comments('a"b #c"\n') == 'a"b    \n'

{links_notation-0.28.0 → links_notation-0.30.0}/tests/test_stream_parser.py

@@ -81,3 +81,13 @@ def test_rejects_writes_after_finish():
     stream.finish("one")
     with pytest.raises(RuntimeError, match="after finish"):
         stream.write("two")
+
+
+def test_waits_for_the_line_that_closes_an_even_run_of_quotes():
+    # ``""`` is the empty reference only when nothing closes it, and here the
+    # next line does, so the first line cannot be emitted on its own (#377).
+    document = 'a "" b\n"" c\n'
+    stream = StreamParser()
+    for character in document:
+        assert stream.write(character) == []
+    assert format_links(stream.finish()) == format_links(Parser().parse(document))