overleaf-comments-export 0.21.2__tar.gz → 0.22.0__tar.gz

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overleaf-comments-export
-Version: 0.21.2
+Version: 0.22.0
 Summary: Export comment threads and tracked changes from an Overleaf project to Markdown + JSON, optimized for AI-agent consumption.
 Author-email: Shivang Gupta <47645533+Mangluu@users.noreply.github.com>
 License: MIT
@@ -213,6 +213,22 @@ ids, so renumbering never shows up as change. And if you run with different
 filters than last time, deletions are not reported, because a comment hidden by
 `--no-resolved` has not gone anywhere.
 
+## Papers split across files
+
+Most real papers are. The whole project is read in the order LaTeX reads it,
+following `\input`, `\include` and `\subfile` from the root document, so a
+comment gets the section it is actually under even when the `\section` is in
+`main.tex` and the prose is in `results-body.tex`. Figure and table numbers
+run through the whole paper the way LaTeX numbers them, rather than restarting
+in every file.
+
+Files with no comments in them are read too, because a figure in one still
+decides what number the next one gets.
+
+If any included file cannot be read, figure numbers are left off rather than
+guessed, and the export says so. A missing number sends nobody anywhere. A
+wrong one sends them to the wrong figure.
+
 ## Working through comments with an AI
 
 This is what the export is shaped for. Hand an assistant the folder and it can

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/README.md

@@ -169,6 +169,22 @@ ids, so renumbering never shows up as change. And if you run with different
 filters than last time, deletions are not reported, because a comment hidden by
 `--no-resolved` has not gone anywhere.
 
+## Papers split across files
+
+Most real papers are. The whole project is read in the order LaTeX reads it,
+following `\input`, `\include` and `\subfile` from the root document, so a
+comment gets the section it is actually under even when the `\section` is in
+`main.tex` and the prose is in `results-body.tex`. Figure and table numbers
+run through the whole paper the way LaTeX numbers them, rather than restarting
+in every file.
+
+Files with no comments in them are read too, because a figure in one still
+decides what number the next one gets.
+
+If any included file cannot be read, figure numbers are left off rather than
+guessed, and the export says so. A missing number sends nobody anywhere. A
+wrong one sends them to the wrong figure.
+
 ## Working through comments with an AI
 
 This is what the export is shaped for. Hand an assistant the folder and it can

overleaf_comments_export-0.22.0/overleaf_comments_export/docorder.py

@@ -0,0 +1,209 @@
+"""Work out the order LaTeX reads a project in.
+
+A paper split across files is read in the order the root document pulls the
+pieces in, and two things depend on that order rather than on any one file.
+
+Section headings, because `main.tex` can say `\\section{Results}` and then
+`\\input{results-body}`, so the prose and the heading that names it live in
+different files. Read on its own, `results-body.tex` has no heading at all.
+
+Figure and table numbers, because LaTeX counts them straight through the whole
+document. Counted per file they restart, and a comment on Figure 2 gets
+reported as Figure 1, which is worse than saying nothing: it sends somebody to
+the wrong figure.
+
+This module answers only "what order, and did we see everything". Whether a
+number can be claimed at all is decided by the caller, because the answer
+depends on whether the whole chain was readable.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Iterable, Mapping
+
+# \include always takes a .tex file. \input usually does. \subfile is the
+# subfiles package, which is common enough in theses to be worth reading.
+_INCLUDE_RE = re.compile(r"\\(?:input|include|subfile)\s*\{([^}]*)\}")
+# `\input path` without braces is legal TeX and rare in practice. Reading it
+# wrong would invent a file, so it is left alone.
+
+
+def _strip_comments(text: str) -> str:
+    """Blank out commented-out text, keeping offsets so nothing shifts.
+
+    A commented `\\input` is not read by LaTeX and must not be read here. An
+    escaped \\% is not a comment.
+    """
+    out = []
+    for line in text.split("\n"):
+        i, n = 0, len(line)
+        while i < n:
+            if line[i] == "%" and (i == 0 or line[i - 1] != "\\"):
+                line = line[:i] + " " * (n - i)
+                break
+            i += 1
+        out.append(line)
+    return "\n".join(out)
+
+
+def find_includes(text: str) -> list[str]:
+    """The files this one pulls in, in the order it pulls them."""
+    return [m.group(1).strip() for m in _INCLUDE_RE.finditer(_strip_comments(text))
+            if m.group(1).strip()]
+
+
+def _candidates(ref: str) -> list[str]:
+    """What `\\input{sections/intro}` could name on disk.
+
+    TeX lets you leave the extension off, and people write `./` and
+    backslashes, so the reference is normalised before matching.
+    """
+    ref = ref.replace("\\", "/").strip()
+    while ref.startswith("./"):
+        ref = ref[2:]
+    names = [ref] if ref.endswith(".tex") else [f"{ref}.tex", ref]
+    return [n for n in names if n]
+
+
+def _match(ref: str, available: Mapping[str, str]) -> str | None:
+    for name in _candidates(ref):
+        if name in available:
+            return name
+    # A project can say `\input{intro}` for a file the tree calls
+    # `sections/intro.tex`. Match on the tail, but only when it is unambiguous.
+    for name in _candidates(ref):
+        hits = [p for p in available if p == name or p.endswith("/" + name)]
+        if len(hits) == 1:
+            return hits[0]
+    return None
+
+
+def flatten(root: str, texts: Mapping[str, str]
+            ) -> tuple[str, list[tuple[str, int, int]], list[str]]:
+    """Splice the whole project into the single document LaTeX reads.
+
+    Returns the joined source, a list of (pathname, offset in that file,
+    offset in the joined source) marking where each piece landed, and any
+    reference that could not be found.
+
+    Whole files are not enough. `\\input` happens at a point, so a file pulled
+    in halfway through the root inherits only the headings above that point,
+    and its content sits before everything below it. Treating inclusion as
+    file-level puts the pieces in the wrong order, which is how a first
+    attempt at this gave an included file the heading that came after it.
+    """
+    parts: list[str] = []
+    marks: list[tuple[str, int, int]] = []
+    missing: list[str] = []
+    depth: set[str] = set()
+    total = 0
+
+    def emit(path: str, text: str, lo: int, hi: int) -> None:
+        nonlocal total
+        marks.append((path, lo, total))
+        chunk = text[lo:hi]
+        parts.append(chunk)
+        total += len(chunk)
+
+    def walk(path: str) -> None:
+        nonlocal total
+        if path in depth:
+            return                   # a ring of includes; LaTeX would fail too
+        depth.add(path)
+        text = texts[path]
+        stripped = _strip_comments(text)
+        cursor = 0
+        for m in _INCLUDE_RE.finditer(stripped):
+            ref = m.group(1).strip()
+            if not ref:
+                continue
+            emit(path, text, cursor, m.start())
+            cursor = m.end()
+            target = _match(ref, texts)
+            if target is None:
+                missing.append(ref)
+            else:
+                walk(target)
+                # \include starts a new page, so anything counted per page
+                # would reset here. Nothing here counts per page.
+        emit(path, text, cursor, len(text))
+        depth.discard(path)
+
+    if root not in texts:
+        return "", [], [root]
+    walk(root)
+    return "".join(parts), marks, missing
+
+
+def locate(marks: list[tuple[str, int, int]], path: str, offset: int) -> int | None:
+    """Where a position in one file landed in the joined source."""
+    best = None
+    for mark_path, lo, at in marks:
+        if mark_path == path and lo <= offset:
+            if best is None or lo > best[0]:
+                best = (lo, at)
+    return None if best is None else best[1] + (offset - best[0])
+
+
+def resolve_order(root: str, texts: Mapping[str, str]) -> tuple[list[str], list[str]]:
+    """Files in the order LaTeX reads them, and any reference we could not find.
+
+    `texts` maps pathname to source. Returns (ordered pathnames, unresolved
+    references). A non-empty second list means the picture is incomplete, and
+    anything counted across the whole document cannot be trusted.
+    """
+    if root not in texts:
+        return [], [root]
+
+    order: list[str] = []
+    missing: list[str] = []
+    seen: set[str] = set()
+
+    def walk(path: str) -> None:
+        # A file that includes itself, directly or in a ring, would recurse
+        # forever. LaTeX would also fail; here it just stops.
+        if path in seen:
+            return
+        seen.add(path)
+        order.append(path)
+        for ref in find_includes(texts[path]):
+            target = _match(ref, texts)
+            if target is None:
+                missing.append(ref)
+            else:
+                walk(target)
+
+    walk(root)
+    return order, missing
+
+
+def reachable(root: str, texts: Mapping[str, str],
+              known_paths: Iterable[str]) -> list[str]:
+    """Files named from `root` that we have not read yet.
+
+    Used to fetch the rest of the chain: a file with no comments in it still
+    holds figures that decide what number the next one gets.
+    """
+    known = set(known_paths)
+    want: list[str] = []
+    seen: set[str] = set()
+
+    def walk(path: str, source: str) -> None:
+        if path in seen:
+            return
+        seen.add(path)
+        for ref in find_includes(source):
+            target = _match(ref, texts)
+            if target is not None:
+                walk(target, texts[target])
+                continue
+            for name in _candidates(ref):
+                hits = [p for p in known if p == name or p.endswith("/" + name)]
+                if len(hits) == 1 and hits[0] not in want:
+                    want.append(hits[0])
+                    break
+
+    if root in texts:
+        walk(root, texts[root])
+    return want

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/overleaf_comments_export/export.py

@@ -5,6 +5,7 @@ import logging
 import os
 import re
 import shutil
+from bisect import bisect_right
 from dataclasses import dataclass
 from datetime import date, datetime, timezone
 from pathlib import Path
@@ -24,7 +25,9 @@ from .model import (
     TrackedChange,
 )
 from .render import render_markdown, render_response_letter
-from .sections import enclosing_float, find_floats, find_headings, nearest_heading
+from .docorder import flatten, locate, reachable
+from .sections import (enclosing_float, find_floats, find_headings,
+                       nearest_heading)
 from .since import (SINCE_FILENAME, compare, load_previous, render_since,
                     short_ids)
 
@@ -341,6 +344,98 @@ def _slug_reviewer(name: str) -> str:
     return s[:60] or "reviewer"
 
 
+def _apply_document_order(client, project_id, doc_texts, doc_id_to_path,
+                          root_doc_id, anchored, changes, progress) -> None:
+    """Number floats and name sections across the whole document, not per file.
+
+    Only the files carrying comments were downloaded, and that is not enough:
+    a file with no comments in it still holds figures that decide what number
+    the next one gets. The rest of the chain is fetched here.
+
+    The pieces are then spliced into the single document LaTeX reads, and the
+    headings and float counters are worked out over that. Doing it file by
+    file is not equivalent, because `\\input` happens at a point: a file pulled
+    in halfway through the root inherits only the headings above that point.
+
+    If any part of the chain cannot be read, no number is claimed at all. A
+    missing number sends nobody anywhere. A wrong one sends them to the wrong
+    figure.
+    """
+    by_path = {d.pathname: d for d in doc_texts.values()}
+    root_path = doc_id_to_path.get(root_doc_id or "")
+    if not root_path or root_path not in by_path and root_path not in doc_id_to_path.values():
+        return
+
+    path_to_doc_id = {v: k for k, v in doc_id_to_path.items()}
+    texts = {p: d.text for p, d in by_path.items()}
+
+    if root_path not in texts:
+        doc_id = path_to_doc_id.get(root_path)
+        try:
+            texts[root_path] = client.download_doc_text(project_id, doc_id)
+        except Exception as e:
+            logger.warning("Could not read the root document %s: %s", root_path, e)
+            return
+
+    # Includes nest, so widen the set until nothing new is named.
+    for _ in range(8):
+        wanted = [p for p in reachable(root_path, texts, path_to_doc_id)
+                  if p not in texts]
+        if not wanted:
+            break
+        got = False
+        for path in wanted:
+            doc_id = path_to_doc_id.get(path)
+            if not doc_id:
+                continue
+            try:
+                texts[path] = client.download_doc_text(project_id, doc_id)
+                got = True
+            except Exception as e:
+                logger.warning("Could not read %s for numbering: %s", path, e)
+        if not got:
+            break
+
+    joined, marks, missing = flatten(root_path, texts)
+    if not joined:
+        return
+
+    if missing:
+        progress(f"Could not read {len(missing)} included file(s), so figure and "
+                 f"table numbers are left off rather than guessed.")
+        logger.info("Unresolved includes: %s", ", ".join(sorted(set(missing))[:10]))
+        for doc in doc_texts.values():
+            for f in doc.floats:
+                f.number = None
+        return
+
+    files_read = len({p for p, _, _ in marks})
+    if files_read < 2:
+        return                          # one file: per-file numbering is right
+
+    starts = build_line_starts(joined)
+    floats = find_floats(joined, starts)
+    headings = find_headings(joined, starts)
+
+    def relocate(doc_id: str, offset: int) -> int | None:
+        doc = doc_texts.get(doc_id)
+        return None if doc is None else locate(marks, doc.pathname, offset)
+
+    for c in anchored:
+        at = relocate(c.doc_id, c.offset)
+        if at is None:
+            continue
+        c.float_ref = enclosing_float(floats, at)
+        c.nearest_heading = nearest_heading(headings, bisect_right(starts, at))
+    for ch in changes:
+        at = relocate(ch.doc_id, ch.offset)
+        if at is not None:
+            ch.nearest_heading = nearest_heading(headings, bisect_right(starts, at))
+
+    progress(f"Read {files_read} file(s) in document order, so sections and "
+             f"figure numbers follow the whole paper.")
+
+
 def _commit(stage: Path, out_dir: Path) -> int:
     """Move a finished export into the folder the user chose.
 
@@ -654,6 +749,18 @@ def run_export(
                 "file/line anchors."
             )
 
+        # ---- Put the files in the order LaTeX reads them ----
+        #
+        # Two things depend on that order and on nothing in any single file:
+        # which section a comment sits under, when the heading is in the root
+        # and the prose is in an included file, and what number a figure
+        # carries, since LaTeX counts straight through the whole document.
+        # Counted per file the numbers restart, so a comment on Figure 2 was
+        # reported as Figure 1.
+        _apply_document_order(
+            client, project_id, doc_texts, doc_id_to_path,
+            metadata.get("rootDocId"), anchored, changes, progress)
+
         orphan_threads = [
             thread for tid, thread in threads.items() if tid not in referenced_thread_ids
         ]

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/overleaf_comments_export/gui.py

@@ -1013,25 +1013,34 @@ class App:
         as a bundled application, so it usually is not. The dialog appears
         behind whatever the person was looking at, the window stops redrawing
         because it is waiting on it, and the whole thing reads as a hang.
-        Measured: without this the app never becomes the frontmost process, and
-        `parent=` on its own does not do it either.
+
+        Lift and focus only. An earlier version toggled `-topmost` around the
+        call and the app died with "cannot run nil sheetWindow": toggling it
+        churns the underlying NSWindow, and a sheet opening on a window in
+        that state throws. Turning a hang into a crash is not an improvement.
         """
         try:
             self.root.lift()
-            self.root.attributes("-topmost", True)
             self.root.focus_force()
-            # Dropped again straight away, or the window would sit above
-            # everything else for the rest of the session.
-            self.root.after_idle(self.root.attributes, "-topmost", False)
+            # Let the window settle before anything modal opens on top of it.
+            self.root.update_idletasks()
         except tk.TclError:
             pass
 
     def _pick_folder(self) -> None:
         self._to_front()
-        chosen = filedialog.askdirectory(
-            parent=self.root,
-            initialdir=self.out_var.get() or str(Path.home()),
-            title="Choose a folder to save the comments into", mustexist=False)
+        try:
+            chosen = filedialog.askdirectory(
+                initialdir=self.out_var.get() or str(Path.home()),
+                title="Choose a folder to save the comments into",
+                mustexist=False)
+        except tk.TclError as e:
+            # The box beside the button is an ordinary text field, so a picker
+            # that will not open is an annoyance rather than a dead end.
+            logger.warning("The folder picker failed: %s", e)
+            self._set_status("The folder picker would not open. Type or paste "
+                             "the folder path into the box instead.", "bad")
+            return
         if chosen:
             self.out_var.set(chosen)
 

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/overleaf_comments_export/sections.py

@@ -79,10 +79,19 @@ def find_headings(text: str, line_starts: list[int]) -> list[Heading]:
     return headings
 
 
-def nearest_heading(headings: list[Heading], line_no: int) -> str | None:
+def nearest_heading(headings: list[Heading], line_no: int,
+                    inherited: list[Heading] | None = None) -> str | None:
     """Return a path like "§ 3.2 Method overview" for the nearest enclosing
-    heading at-or-above line_no."""
+    heading at-or-above line_no.
+
+    `inherited` is the heading context in force where this file was pulled in.
+    A paper can say `\\section{Results}` in the root and then
+    `\\input{results-body}`, so read on its own the included file has no
+    heading at all and every comment in it came back with nothing.
+    """
     enclosing: dict[int, Heading] = {}
+    for h in inherited or []:
+        enclosing[h.level] = h
     for h in headings:
         if h.line_no > line_no:
             break
@@ -141,15 +150,21 @@ def _balanced_argument(text: str, open_brace: int) -> str:
     return text[open_brace + 1:]
 
 
-def find_floats(text: str, line_starts: list[int]) -> list[Float]:
+def find_floats(text: str, line_starts: list[int],
+                start: dict[str, int] | None = None) -> list[Float]:
     """Every figure and table in the source, numbered as LaTeX would.
 
     Only captioned floats take a number, because LaTeX only steps the counter
     when there is a caption. An uncaptioned float still gets recorded, so a
     comment inside one can say it is in a figure even when it cannot say which.
+
+    `start` carries the counters in from the files LaTeX read before this one.
+    Without it every file starts at one, so in a paper split across files the
+    second file's Figure 2 is reported as Figure 1. `count_floats` produces
+    the value to pass in.
     """
     floats: list[Float] = []
-    counters = {"figure": 0, "table": 0}
+    counters = {"figure": 0, "table": 0} | dict(start or {})
 
     for m in _FLOAT_BEGIN_RE.finditer(text):
         if _commented_out(text, m.start()):
@@ -174,6 +189,15 @@ def find_floats(text: str, line_starts: list[int]) -> list[Float]:
     return floats
 
 
+def count_floats(floats: list[Float]) -> dict[str, int]:
+    """The counters after these floats, for handing to the next file."""
+    out = {"figure": 0, "table": 0}
+    for f in floats:
+        if f.number is not None:
+            out[f.kind] = max(out[f.kind], f.number)
+    return out
+
+
 def _matching_end(text: str, after_begin: int) -> int:
     """Where this float closes, counting nested floats on the way."""
     depth = 1

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/overleaf_comments_export.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overleaf-comments-export
-Version: 0.21.2
+Version: 0.22.0
 Summary: Export comment threads and tracked changes from an Overleaf project to Markdown + JSON, optimized for AI-agent consumption.
 Author-email: Shivang Gupta <47645533+Mangluu@users.noreply.github.com>
 License: MIT
@@ -213,6 +213,22 @@ ids, so renumbering never shows up as change. And if you run with different
 filters than last time, deletions are not reported, because a comment hidden by
 `--no-resolved` has not gone anywhere.
 
+## Papers split across files
+
+Most real papers are. The whole project is read in the order LaTeX reads it,
+following `\input`, `\include` and `\subfile` from the root document, so a
+comment gets the section it is actually under even when the `\section` is in
+`main.tex` and the prose is in `results-body.tex`. Figure and table numbers
+run through the whole paper the way LaTeX numbers them, rather than restarting
+in every file.
+
+Files with no comments in them are read too, because a figure in one still
+decides what number the next one gets.
+
+If any included file cannot be read, figure numbers are left off rather than
+guessed, and the export says so. A missing number sends nobody anywhere. A
+wrong one sends them to the wrong figure.
+
 ## Working through comments with an AI
 
 This is what the export is shaped for. Hand an assistant the folder and it can

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/overleaf_comments_export.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ overleaf_comments_export/__main__.py
 overleaf_comments_export/anchors.py
 overleaf_comments_export/annotate.py
 overleaf_comments_export/client.py
+overleaf_comments_export/docorder.py
 overleaf_comments_export/doctor.py
 overleaf_comments_export/export.py
 overleaf_comments_export/filenames.py
@@ -26,6 +27,7 @@ tests/test_anchors_sections.py
 tests/test_annotate.py
 tests/test_cancel.py
 tests/test_client.py
+tests/test_docorder.py
 tests/test_doctor.py
 tests/test_errors_and_auth.py
 tests/test_export.py

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overleaf-comments-export"
-version = "0.21.2"
+version = "0.22.0"
 description = "Export comment threads and tracked changes from an Overleaf project to Markdown + JSON, optimized for AI-agent consumption."
 readme = "README.md"
 license = { text = "MIT" }

overleaf_comments_export-0.22.0/tests/test_docorder.py

@@ -0,0 +1,208 @@
+"""Multi-file papers: the order LaTeX reads them in, and what depends on it.
+
+Two things depend on the whole document rather than on any one file. Which
+section a comment sits under, when the heading is in the root and the prose is
+in an included file. And what number a figure carries, since LaTeX counts
+straight through. Counted per file the numbers restart, and a comment on
+Figure 2 came back as Figure 1, which is worse than saying nothing.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from overleaf_comments_export import export as export_mod
+from overleaf_comments_export.docorder import (find_includes, flatten, locate,
+                                               resolve_order)
+from tests.test_export_wiring import FakeClient
+
+URL = "https://www.overleaf.com/project/" + "a" * 24
+
+
+# --- reading the includes ---------------------------------------------------
+
+def test_every_way_a_paper_pulls_in_a_file():
+    text = (r"\input{a}" "\n" r"\include{b}" "\n" r"\subfile{c}" "\n"
+            r"\input{sub/dir/d.tex}")
+    assert find_includes(text) == ["a", "b", "c", "sub/dir/d.tex"]
+
+
+def test_a_commented_out_include_is_not_read():
+    """LaTeX does not read it, so neither does this. Reading it would invent a
+    file and, worse, invent figures that shift every later number."""
+    assert find_includes("% \\input{draft}\n\\input{real}") == ["real"]
+    assert find_includes("\\input{real} % \\input{draft}") == ["real"]
+    # An escaped percent is not a comment.
+    assert find_includes(r"100\% \input{real}") == ["real"]
+
+
+@pytest.mark.parametrize("ref", ["intro", "intro.tex", "./intro", "sections/intro"])
+def test_a_reference_finds_its_file_however_it_is_written(ref):
+    texts = {"main.tex": "\\input{%s}" % ref, "sections/intro.tex": "x"}
+    order, missing = resolve_order("main.tex", texts)
+    assert missing == []
+    assert order == ["main.tex", "sections/intro.tex"]
+
+
+def test_a_ring_of_includes_stops_instead_of_recursing():
+    texts = {"a.tex": "\\input{b}", "b.tex": "\\input{a}"}
+    joined, marks, missing = flatten("a.tex", texts)
+    assert missing == []          # both were found; it simply stops
+
+
+def test_a_file_that_is_not_there_is_reported():
+    texts = {"main.tex": "\\input{gone}"}
+    _, _, missing = flatten("main.tex", texts)
+    assert missing == ["gone"]
+
+
+# --- the splice -------------------------------------------------------------
+
+def test_an_included_file_lands_where_the_include_sits():
+    """Not at the end of the parent. `\\input` happens at a point, and treating
+    it as file-level is what gave an included file the heading below it."""
+    joined, marks, _ = flatten("main.tex", {"main.tex": "A \\input{b} C", "b.tex": "BBB"})
+    assert joined == "A BBB C"
+    assert locate(marks, "b.tex", 0) == 2
+    assert locate(marks, "main.tex", 12) == 6      # the C, after the splice
+
+
+# --- what it is all for -----------------------------------------------------
+
+FILES = {
+    "d_main": ("main.tex",
+               "\\documentclass{article}\n\\begin{document}\n"
+               "\\section{Results}\n\\input{results-body}\n"
+               "\\begin{figure}\\caption{First}\\label{fig:a}\\end{figure}\n"
+               "\\input{extra-figures}\n"
+               "\\section{Discussion}\n\\input{discussion-body}\n\\end{document}\n"),
+    "d_results": ("results-body.tex", "Task time fell by twelve percent.\n"),
+    # No comment in here at all, but its figure still moves the counter on.
+    "d_extra": ("extra-figures.tex",
+                "\\begin{figure}\\caption{Nobody commented}\\end{figure}\n"),
+    "d_disc": ("discussion-body.tex",
+               "\\begin{figure}\\caption{Fourth}\\label{fig:d}\\end{figure}\n"
+               "The effect is smaller than we expected.\n"),
+}
+ANCHORS = {"d_results": ("twelve percent", "t1"),
+           "d_disc": ("Fourth", "t2"),
+           "d_main": ("First", "t3")}
+
+
+def _threads():
+    return {tid: {"resolved": False,
+                  "messages": [{"id": f"m{tid}", "content": "note",
+                                "timestamp": 1_700_000_000_000, "user_id": "u1",
+                                "user": {"name": "R"}}]}
+            for _, tid in ANCHORS.values()}
+
+
+class MultiFile(FakeClient):
+    unreadable: set[str] = set()
+
+    def get_threads(self, project_id):
+        return _threads()
+
+    def get_resolved_thread_ids(self, project_id):
+        return []
+
+    def get_project_metadata(self, project_id):
+        return {"files": {"docs": []}, "name": "Paper",
+                "rootDocId": "d_main", "raw_meta": {}}
+
+    def flatten_files(self, files_root, debug_logger=None):
+        return [{"doc_id": d, "pathname": p} for d, (p, _) in FILES.items()]
+
+    def get_project_ranges(self, project_id):
+        return [{"id": d, "ranges": {
+            "comments": [{"op": {"p": FILES[d][1].index(txt), "c": txt, "t": tid}}],
+            "changes": []}} for d, (txt, tid) in ANCHORS.items()]
+
+    def download_doc_text(self, project_id, doc_id):
+        if doc_id in self.unreadable:
+            raise RuntimeError("cannot read this one")
+        return FILES[doc_id][1]
+
+
+@pytest.fixture()
+def multi(monkeypatch):
+    MultiFile.unreadable = set()
+    monkeypatch.setattr(export_mod, "OverleafClient", MultiFile)
+
+
+def _comments(tmp_path):
+    result = export_mod.run_export(project_url=URL, out_dir=tmp_path)
+    payload = json.loads(result.json_path.read_text(encoding="utf-8"))
+    return {c["short_id"]: c for c in payload["comments"]}
+
+
+def test_figure_numbers_run_through_the_whole_paper(tmp_path, multi):
+    """The bug in #12. Counted per file these were Figure 1 and Figure 1."""
+    by_path = {c["pathname"]: c for c in _comments(tmp_path).values()}
+    assert by_path["main.tex"]["enclosing_float"]["number"] == 1
+    # 2 is in extra-figures.tex, which carries no comment and was never
+    # downloaded until this feature went in. Miss it and this reads 2.
+    assert by_path["discussion-body.tex"]["enclosing_float"]["number"] == 3
+
+
+def test_a_comment_in_an_included_file_gets_its_section(tmp_path, multi):
+    """The heading is in main.tex and the prose is not, so on its own the
+    included file has no heading at all."""
+    by_path = {c["pathname"]: c for c in _comments(tmp_path).values()}
+    assert by_path["results-body.tex"]["nearest_heading"] == "Results"
+    assert by_path["discussion-body.tex"]["nearest_heading"] == "Discussion"
+
+
+def test_the_section_is_the_one_above_the_include_not_below_it(tmp_path, multi):
+    """results-body is pulled in under Results, and Discussion comes after.
+    A first attempt at this handed it Discussion, because it carried the whole
+    parent file's headings across instead of only those above the include."""
+    by_path = {c["pathname"]: c for c in _comments(tmp_path).values()}
+    assert by_path["results-body.tex"]["nearest_heading"] != "Discussion"
+
+
+def test_an_unreadable_file_means_no_numbers_rather_than_wrong_ones(tmp_path,
+                                                                    multi):
+    """Missing sends nobody anywhere. Wrong sends them to the wrong figure."""
+    MultiFile.unreadable = {"d_extra"}
+    numbers = [c["enclosing_float"]["number"]
+               for c in _comments(tmp_path).values() if c["enclosing_float"]]
+    assert numbers and all(n is None for n in numbers), numbers
+
+
+def test_a_single_file_paper_is_unaffected(tmp_path, monkeypatch):
+    """The common case must not change, and must not fetch anything extra."""
+    text = ("\\section{Method}\n"
+            "\\begin{figure}\\caption{Only}\\label{fig:o}\\end{figure}\n"
+            "We crossed three sensory environments in a controlled study.\n")
+
+    class Single(FakeClient):
+        def get_threads(self, project_id):
+            return {"t1": {"resolved": False, "messages": [
+                {"id": "m1", "content": "note", "timestamp": 1_700_000_000_000,
+                 "user_id": "u1", "user": {"name": "R"}}]}}
+
+        def get_resolved_thread_ids(self, project_id):
+            return []
+
+        def get_project_metadata(self, project_id):
+            return {"files": {"docs": []}, "name": "P", "rootDocId": "d1",
+                    "raw_meta": {}}
+
+        def flatten_files(self, files_root, debug_logger=None):
+            return [{"doc_id": "d1", "pathname": "main.tex"}]
+
+        def get_project_ranges(self, project_id):
+            return [{"id": "d1", "ranges": {"comments": [
+                {"op": {"p": text.index("Only"), "c": "Only", "t": "t1"}}],
+                "changes": []}}]
+
+        def download_doc_text(self, project_id, doc_id):
+            return text
+
+    monkeypatch.setattr(export_mod, "OverleafClient", Single)
+    c = list(_comments(tmp_path).values())[0]
+    assert c["enclosing_float"]["number"] == 1
+    assert c["nearest_heading"] == "Method"

{overleaf_comments_export-0.21.2 → overleaf_comments_export-0.22.0}/tests/test_gui.py

@@ -293,7 +293,11 @@ def test_the_window_comes_forward_before_the_folder_dialog(app, monkeypatch):
 
     def fake_dialog(**kwargs):
         order.append("dialog")
-        assert kwargs.get("parent") is app.root, "the dialog is not attached"
+        # No parent. On macOS that makes the picker a sheet attached to the
+        # window, and a sheet opening on a window whose NSWindow is not in a
+        # good state dies with "cannot run nil sheetWindow". A free-standing
+        # panel cannot fail that way.
+        assert "parent" not in kwargs, "parent= brings back the sheet crash"
         return "/tmp/chosen"
 
     monkeypatch.setattr(gui.filedialog, "askdirectory", fake_dialog)
@@ -316,9 +320,16 @@ def test_every_modal_brings_the_window_forward_first(app):
                 f"this dialog can open behind the window:\n    {line.strip()}")
 
 
-def test_bringing_the_window_forward_does_not_pin_it_there(app):
-    """-topmost has to come off again, or the window sits above everything
-    else for the rest of the session."""
+def test_bringing_the_window_forward_never_touches_topmost(app):
+    """Toggling -topmost around the dialog churns the underlying NSWindow, and
+    the app died with "cannot run nil sheetWindow" because of it. Lifting and
+    focusing is enough and cannot fail that way."""
+    import inspect
+
+    # The call, not the word. The docstring says "topmost" precisely because
+    # it explains why this does not use it.
+    source = inspect.getsource(type(app)._to_front)
+    assert '"-topmost"' not in source, "topmost is back, and so is the crash"
+    assert "'-topmost'" not in source
     app._to_front()
-    app.root.update_idletasks()          # runs the after_idle that drops it
     assert not app.root.attributes("-topmost")