pulli 0.2.11__tar.gz → 0.2.13__tar.gz

{pulli-0.2.11 → pulli-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pulli
-Version: 0.2.11
+Version: 0.2.13
 Summary: Walk a directory tree, show git repos with status, and fast-forward the ones that are behind upstream.
 Author: Stefan Waldherr
 License-Expression: MIT

{pulli-0.2.11 → pulli-0.2.13}/src/pulli/__init__.py

@@ -1,2 +1,2 @@
 """pulli — discover git repos under a root and report their status."""
-__version__ = "0.2.11"
+__version__ = "0.2.13"

{pulli-0.2.11 → pulli-0.2.13}/src/pulli/cli.py

@@ -132,8 +132,8 @@ def build_parser() -> argparse.ArgumentParser:
     tree_p.add_argument(
         "--max-depth",
         type=int,
-        default=50,
-        help="Maximum recursion depth (default: 50).",
+        default=2,
+        help="Maximum recursion depth (default: 2).",
     )
     tree_p.add_argument(
         "--tree",
@@ -188,8 +188,8 @@ def build_parser() -> argparse.ArgumentParser:
     pull_p.add_argument(
         "--max-depth",
         type=int,
-        default=50,
-        help="Maximum recursion depth (default: 50).",
+        default=2,
+        help="Maximum recursion depth (default: 2).",
     )
 
     # `pulli update` — self-update.
@@ -386,6 +386,12 @@ def _run_tree(args) -> int:
         # Stream: print the skeleton immediately, then fill each repo's
         # status line in as it becomes ready — no blank-screen wait.
         live = LiveTree(tree, use_color=use_color, flat=flat)
+        if flat and not args.no_summary:
+            # The summary prints its own skeleton line right away ("N
+            # repos…") and rewrites it in place as statuses land — same
+            # deal as the repo lines, so the eye has the answer's shape from
+            # the first frame on.
+            print(f"{len(repos)} repos…")
         fetch_and_status(
             repos,
             quiet=True,
@@ -394,10 +400,10 @@ def _run_tree(args) -> int:
             on_done=live.update,
         )
         if flat and not args.no_summary:
-            # The live tree is done rewriting lines; the summary lands
-            # below it, where the eye ends up anyway.
-            print()
-            print(_summary(list(iter_repos(tree)), use_color))
+            # Rewrite the skeleton summary in place: one line up, clear,
+            # print the real one. The tree is done rewriting its lines, so
+            # the cursor is already at the bottom.
+            sys.stdout.write("\r\x1b[2K" + _summary(list(iter_repos(tree)), use_color) + "\n")
     else:
         # Not a terminal: no in-place cursor control. Do the work, then
         # print the complete output once (byte-identical to before).

{pulli-0.2.11 → pulli-0.2.13}/src/pulli/discovery.py

@@ -258,6 +258,13 @@ def _walk_links(
     would win and the actual directory would disappear from the tree, which
     is backwards. Walking links last means a real directory always wins, and
     a link is only shown when nothing else reaches its target.
+
+    This pass also descends into plain directories the first walk skipped
+    (plain dirs inside a repo are never recorded as nodes) looking for
+    symlinks: a repo checked out *inside* another repo often keeps links to
+    sibling repos in a dot-dir (`.links/`), and those links are the whole
+    point of the layout. Plain dirs found this way are traversed, not
+    recorded — the tree stays as small as before.
     """
     # As in _walk: a node deeper than max_depth is not expanded. The link
     # pass must respect the same limit as the plain walk, or --max-depth
@@ -275,6 +282,23 @@ def _walk_links(
         link = real_dir / name
         try:
             if not link.is_symlink():
+                # Not a link: still look *inside* for links (the .links/
+                # case) — but only one level of plain-dir descent, so a
+                # repo's src/ tree is not pointlessly scanned. The dir
+                # becomes a real node so links land under it, not under
+                # the repo root.
+                if link.is_dir() and not _is_pruned(name):
+                    dir_node = RepoNode(
+                        path=link,
+                        link_path=display_dir / name,
+                        name=name,
+                        depth=node.depth + 1,
+                        parent=node,
+                    )
+                    _walk_links_plain(dir_node, link, display_dir / name,
+                                      max_depth, visited)
+                    if dir_node.children:
+                        node.children.append(dir_node)
                 continue
             target = link.resolve(strict=True)
         except (OSError, RuntimeError):
@@ -318,6 +342,63 @@ def _walk_links(
     node.children.sort(key=lambda c: c.name.lower())
 
 
+def _walk_links_plain(
+    node: RepoNode,
+    real_dir: Path,
+    display_dir: Path,
+    max_depth: int,
+    visited: set[Path],
+) -> None:
+    """Look for symlinks inside a plain dir the first walk never recorded
+    (plain dirs inside a repo are skipped there). Records only the links
+    themselves as children of `node` — the plain dir stays invisible, so the
+    tree does not grow a directory per level of indirection.
+
+    Bounded to one level: the `.links/` layout is one dir of links; a full
+    recursive scan of a repo's working tree would be noise and cost.
+    """
+    try:
+        entries = sorted(os.listdir(real_dir), key=lambda s: s.lower())
+    except OSError:
+        return
+    for name in entries:
+        if name == ".git":
+            continue
+        link = real_dir / name
+        try:
+            if not link.is_symlink():
+                continue
+            target = link.resolve(strict=True)
+        except (OSError, RuntimeError):
+            continue
+        if not target.is_dir():
+            continue
+        display = display_dir / name
+        already = target in visited
+        if not already:
+            visited.add(target)
+        try:
+            is_repo = _is_git_dir(target)
+        except OSError:
+            continue
+        child = RepoNode(
+            path=target,
+            link_path=display,
+            name=name,
+            depth=node.depth + 1,
+            parent=node,
+            is_symlink=True,
+            symlink_target=_readlink(link),
+            is_repo=is_repo and not already,
+            is_alias=already,
+        )
+        node.children.append(child)
+        if is_repo and not already:
+            _add_submodules(child, target, display, node.depth + 1, visited)
+
+    node.children.sort(key=lambda c: c.name.lower())
+
+
 def _add_submodules(
     parent: RepoNode,
     repo_root: Path,