pulli 0.2.10__tar.gz → 0.2.12__tar.gz

{pulli-0.2.10 → pulli-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pulli
-Version: 0.2.10
+Version: 0.2.12
 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.10 → pulli-0.2.12}/src/pulli/__init__.py

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

{pulli-0.2.10 → pulli-0.2.12}/src/pulli/cli.py

@@ -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.10 → pulli-0.2.12}/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,

{pulli-0.2.10 → pulli-0.2.12}/src/pulli/status.py

@@ -157,22 +157,28 @@ def _remote_url(repo: Path, env: dict[str, str] | None = None) -> str:
 def _is_fork(repo: Path, env: dict[str, str] | None = None) -> bool:
     """True when the repo looks like a fork.
 
-    A fork's remotes point at the same repo *name* under different *owners*
-    — `devskale/rodney` (origin, the user's copy) and `simonw/rodney`
-    (fork/upstream, the parent). Same name + different owner across 2+
-    remotes is the signal; we never need to ask GitHub.
+    Two signals, either one is enough:
+      1. a remote named `upstream` — the documented GitHub convention for
+         "the repo I forked from";
+      2. remotes pointing at the same repo *name* under different *owners*
+         (`devskale/rodney` + `simonw/rodney`), compared case-insensitively.
+
+    Name comparison alone misses forks whose copy was renamed
+    (`devskale/handyST` forked from `cjpais/Handy`) — hence signal 1.
     """
     remotes = _git_one(repo, "remote", env=env).split()
     if len(remotes) < 2:
         return False
+    if "upstream" in remotes:
+        return True
     owners: set[str] = set()
     names: set[str] = set()
     for name in remotes:
         url = _git_one(repo, "remote", "get-url", name, env=env)
         owner, rname = _owner_repo(url)
         if rname:
-            owners.add(owner)
-            names.add(rname)
+            owners.add(owner.lower())
+            names.add(rname.lower())
     # same repo name under more than one owner = a fork and its parent
     return len(names) == 1 and len(owners) >= 2