check-symlinks 0.6.0__tar.gz

check_symlinks-0.6.0/.gitignore

@@ -0,0 +1,41 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# python packaging
+dist/
+*.egg-info/
+__pycache__
+*.whl
+
+# build artifacts: check-symlinks is the go/gocompat binary main_test.go
+# builds, -go and -so the two toolchains' pre-commit outputs, .so-bin the
+# pinned solod toolchain the hatch hook installs.
+/check-symlinks
+/check-symlinks-go
+/check-symlinks-so
+/.so-bin/
+
+.aider*

check_symlinks-0.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jamison Lahman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

check_symlinks-0.6.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.5
+Name: check-symlinks
+Version: 0.6.0
+Summary: Check for broken symlinks
+Project-URL: Repository, https://github.com/jmelahman/check-symlinks
+Author-email: Jamison Lahman <jamison@lahman.dev>
+License: MIT License
+        
+        Copyright (c) 2025 Jamison Lahman
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: ci,continuous-integration,linter,symlinks,tooling,tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Go
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# Check Symlinks
+
+[![Test status](https://github.com/jmelahman/check-symlinks/actions/workflows/test.yml/badge.svg)](https://github.com/jmelahman/check-symlinks/actions)
+[![Deploy Status](https://github.com/jmelahman/check-symlinks/actions/workflows/release.yml/badge.svg)](https://github.com/jmelahman/check-symlinks/actions)
+[![Arch User Repsoitory](https://img.shields.io/aur/version/check-symlinks)](https://aur.archlinux.org/packages/check-symlinks)
+[![PyPI](https://img.shields.io/pypi/v/check-symlinks.svg)](https://pypi.org/project/check-symlinks/)
+
+Check for broken symbolic links.
+
+```shell
+$ check-symlinks
+Broken symlink: some/path/broken_link
+```
+
+`check-symlinks` is optimized for large codebases as well as small, incremental checks,
+
+<p align="center">
+  <picture align="center">
+    <source media="(prefers-color-scheme: dark)" srcset="docs/benchmark-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="docs/benchmark-light.svg">
+    <img alt="Bar chart of benchmark results: check-symlinks 4.0 ms, fd 15.6 ms, check_symlinks.py 104.3 ms, find 150.1 ms, shell loop 225.4 ms." src="docs/benchmark-light.svg">
+  </picture>
+</p>
+
+where the full commands are respectively,
+
+```shell
+check-symlinks
+
+fd --type symlink --exec sh -c 'test -e "$0"'
+
+git ls-files | xargs pre_commit_hooks/check_symlinks.py
+
+find . -type l ! -exec test -e {} \; -print0 | xargs --no-run-if-empty -0 git ls-files
+
+while read file; do test -e "$file"; done < <(git ls-files)
+```
+
+and `check_symlinks.py` is from [https://github.com/pre-commit/pre-commit-hooks](https://github.com/pre-commit/pre-commit-hooks/blob/main/pre_commit_hooks/check_symlinks.py).
+Regenerate the chart with `scripts/gen-benchmark-chart.py`, which documents the exact
+hyperfine invocations.
+
+## Install
+
+**pre-commit:**
+
+```yaml
+repos:
+  - repo: https://github.com/jmelahman/check-symlinks
+    rev: v0.6.0
+    hooks:
+      - id: check-symlinks
+```
+
+The `check-symlinks` hook is built from source by pre-commit's Go toolchain and has no
+other dependencies. Use `check-symlinks-system` instead to run a binary already on
+`PATH`.
+
+**AUR:**
+
+`check-symlinks` is available from the [Arch User Repository](https://aur.archlinux.org/packages/check-symlinks).
+
+```shell
+yay -S check-symlinks
+```
+
+**pip:**
+
+`check-symlinks` is available as a [pypi package](https://pypi.org/project/check-symlinks/).
+
+```shell
+pip install check-symlinks
+```
+
+**Binaries:**
+
+Static binaries for Linux and macOS (amd64 and arm64) are attached to every
+[release](https://github.com/jmelahman/check-symlinks/releases).
+
+## Usage
+
+```
+check-symlinks [flags] [path ...]
+```
+
+With no paths, the current directory is walked. Flags must precede the paths.
+
+| Flag | Description |
+| --- | --- |
+| `--hidden` | Include hidden files and directories in the walk. |
+| `--no-ignore` | Ignore `.symlinkignore` / `.config/symlinkignore`. |
+| `--threads N` | Number of worker threads (0 = one per CPU). |
+| `-q`, `--quiet` | Don't print broken links. |
+| `--debug` | Report which ignore file was loaded and which paths it skipped. |
+| `--version` | Print the version and exit. |
+
+Exit status is `0` when every symlink resolves, `1` when at least one is broken, and
+`2` on a usage error.
+
+Paths listed in `.symlinkignore` (or `.config/symlinkignore`) at the top of the
+repository are skipped. Hidden entries are skipped while walking, but a hidden path
+named on the command line is always checked.
+
+## Building
+
+`check-symlinks` is written in [Solod](https://solod.dev), a strict subset of Go that
+translates to C: release binaries are a few hundred kilobytes, start instantly, and
+have no runtime dependencies. The same sources build with either toolchain — see
+[CONTRIBUTING.md](CONTRIBUTING.md).
+
+```shell
+so build -o check-symlinks ./so   # solod (needs the so tool and a C compiler)
+go build .                        # Go, via the gocompat shims
+```
+
+Windows is not supported: Solod's `os` package is POSIX-only.

check_symlinks-0.6.0/README.md

@@ -0,0 +1,116 @@
+# Check Symlinks
+
+[![Test status](https://github.com/jmelahman/check-symlinks/actions/workflows/test.yml/badge.svg)](https://github.com/jmelahman/check-symlinks/actions)
+[![Deploy Status](https://github.com/jmelahman/check-symlinks/actions/workflows/release.yml/badge.svg)](https://github.com/jmelahman/check-symlinks/actions)
+[![Arch User Repsoitory](https://img.shields.io/aur/version/check-symlinks)](https://aur.archlinux.org/packages/check-symlinks)
+[![PyPI](https://img.shields.io/pypi/v/check-symlinks.svg)](https://pypi.org/project/check-symlinks/)
+
+Check for broken symbolic links.
+
+```shell
+$ check-symlinks
+Broken symlink: some/path/broken_link
+```
+
+`check-symlinks` is optimized for large codebases as well as small, incremental checks,
+
+<p align="center">
+  <picture align="center">
+    <source media="(prefers-color-scheme: dark)" srcset="docs/benchmark-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="docs/benchmark-light.svg">
+    <img alt="Bar chart of benchmark results: check-symlinks 4.0 ms, fd 15.6 ms, check_symlinks.py 104.3 ms, find 150.1 ms, shell loop 225.4 ms." src="docs/benchmark-light.svg">
+  </picture>
+</p>
+
+where the full commands are respectively,
+
+```shell
+check-symlinks
+
+fd --type symlink --exec sh -c 'test -e "$0"'
+
+git ls-files | xargs pre_commit_hooks/check_symlinks.py
+
+find . -type l ! -exec test -e {} \; -print0 | xargs --no-run-if-empty -0 git ls-files
+
+while read file; do test -e "$file"; done < <(git ls-files)
+```
+
+and `check_symlinks.py` is from [https://github.com/pre-commit/pre-commit-hooks](https://github.com/pre-commit/pre-commit-hooks/blob/main/pre_commit_hooks/check_symlinks.py).
+Regenerate the chart with `scripts/gen-benchmark-chart.py`, which documents the exact
+hyperfine invocations.
+
+## Install
+
+**pre-commit:**
+
+```yaml
+repos:
+  - repo: https://github.com/jmelahman/check-symlinks
+    rev: v0.6.0
+    hooks:
+      - id: check-symlinks
+```
+
+The `check-symlinks` hook is built from source by pre-commit's Go toolchain and has no
+other dependencies. Use `check-symlinks-system` instead to run a binary already on
+`PATH`.
+
+**AUR:**
+
+`check-symlinks` is available from the [Arch User Repository](https://aur.archlinux.org/packages/check-symlinks).
+
+```shell
+yay -S check-symlinks
+```
+
+**pip:**
+
+`check-symlinks` is available as a [pypi package](https://pypi.org/project/check-symlinks/).
+
+```shell
+pip install check-symlinks
+```
+
+**Binaries:**
+
+Static binaries for Linux and macOS (amd64 and arm64) are attached to every
+[release](https://github.com/jmelahman/check-symlinks/releases).
+
+## Usage
+
+```
+check-symlinks [flags] [path ...]
+```
+
+With no paths, the current directory is walked. Flags must precede the paths.
+
+| Flag | Description |
+| --- | --- |
+| `--hidden` | Include hidden files and directories in the walk. |
+| `--no-ignore` | Ignore `.symlinkignore` / `.config/symlinkignore`. |
+| `--threads N` | Number of worker threads (0 = one per CPU). |
+| `-q`, `--quiet` | Don't print broken links. |
+| `--debug` | Report which ignore file was loaded and which paths it skipped. |
+| `--version` | Print the version and exit. |
+
+Exit status is `0` when every symlink resolves, `1` when at least one is broken, and
+`2` on a usage error.
+
+Paths listed in `.symlinkignore` (or `.config/symlinkignore`) at the top of the
+repository are skipped. Hidden entries are skipped while walking, but a hidden path
+named on the command line is always checked.
+
+## Building
+
+`check-symlinks` is written in [Solod](https://solod.dev), a strict subset of Go that
+translates to C: release binaries are a few hundred kilobytes, start instantly, and
+have no runtime dependencies. The same sources build with either toolchain — see
+[CONTRIBUTING.md](CONTRIBUTING.md).
+
+```shell
+so build -o check-symlinks ./so   # solod (needs the so tool and a C compiler)
+go build .                        # Go, via the gocompat shims
+```
+
+Windows is not supported: Solod's `os` package is POSIX-only.

check_symlinks-0.6.0/build-constraints.txt

@@ -0,0 +1,71 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile - -o build-constraints.txt --universal --generate-hashes
+go-bin==1.26.6 \
+    --hash=sha256:13a3a133530ffd2005b2ce805a93b8bf3f4712807af16f31aeea6aecfaa55721 \
+    --hash=sha256:1f4b3a6f8d7987c032d821ebb69e84ab9be7913b1cd8c45514d9aea21e3dfb7d \
+    --hash=sha256:2440ec27b056a19e9ce7c7e4c323f93a1ec0aa220b83838b9adf319487091582 \
+    --hash=sha256:2f8d76337bdf2e8e12b655c2f2c4827a202d4198c5cb87f0fde8b286bfa5b816 \
+    --hash=sha256:46658f18ce37d71122d25fa48bd7457cf46a3389345e86c5b6decabf1d5ec6ad \
+    --hash=sha256:565537475730612936bf42edddff5d627133c108d9a01561f8033ed09dc0c2ff \
+    --hash=sha256:7f30d0141d8052d9349b6e26c679ff51d14465ae3362ca9d1623ba1076e376a4 \
+    --hash=sha256:ab703942cbb119637e5306085b6f1f14eb51bd6a98b56dd2ff0a06b5afb742f8 \
+    --hash=sha256:c0dbc08e9a5a827966c8f2d6fb627668e78ab0f9732035564e24d046a185d92b \
+    --hash=sha256:efc17389b78138c27ce3c74275a146ce5e2b39c3969f57a170bbcfe303baf91b
+hatch-vcs==0.5.0 \
+    --hash=sha256:0395fa126940340215090c344a2bf4e2a77bcbe7daab16f41b37b98c95809ff9 \
+    --hash=sha256:b49677dbdc597460cc22d01b27ab3696f5e16a21ecf2700fb01bc28e1f2a04a7
+hatchling==1.32.0 \
+    --hash=sha256:0bdbde4a52b06c37e3eca395f85a762bf0ef06fe374fd8ae429dc6be10230f5f \
+    --hash=sha256:0e17c9c3b9aa7c625acc8d0f5b622f107d5049af9ecf5ada4de1aada5be7cdbc
+    # via hatch-vcs
+manygo==0.2.0 \
+    --hash=sha256:322567f555f0c9896e163f4cecdcd5aa6402996933a6a8ec1cea7f67dae9accd \
+    --hash=sha256:90a951179f0d294d7063a4fc5446b52646cff140c386f9c92ca391116a287098
+packaging==26.3 \
+    --hash=sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79 \
+    --hash=sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c
+    # via
+    #   hatchling
+    #   setuptools-scm
+    #   vcs-versioning
+pathspec==1.1.1 \
+    --hash=sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a \
+    --hash=sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189
+    # via hatchling
+pluggy==1.6.0 \
+    --hash=sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+    # via hatchling
+setuptools==84.0.0 \
+    --hash=sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670 \
+    --hash=sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73
+    # via setuptools-scm
+setuptools-scm==10.2.1 \
+    --hash=sha256:4fa7dd82cf8c800df59c9a288c90299b1657ff1ecfc3f5cc00287c5dbf5e27a9 \
+    --hash=sha256:b7c82f4102d389ee57dc66ccdb4f9b4bca3c40ba83b43f1f63d68ccd72db2580
+    # via hatch-vcs
+tomlkit==0.15.1 \
+    --hash=sha256:177a05aece5a8ca5266fd3c448abb47b8d352f09d477d3ca8332db4d89b24304 \
+    --hash=sha256:e25bbf38843005246210a12982776f27f99cb9be67160e14434d0c0d21ee1e97
+    # via hatchling
+trove-classifiers==2026.6.1.19 \
+    --hash=sha256:ab4c4ec93cc4a4e7815fa759906e05e6bb3f2fbd92ea0f897288c6a43efd15b3 \
+    --hash=sha256:c5132b4b61a829d11cfbd2d72e97f20a45ed6edb95e45c5efdeb5e00836b2745
+    # via hatchling
+vcs-versioning==2.3.1 \
+    --hash=sha256:806635bd0ea653c96af98a70624be758d408a989f2cd0b390e63474d99f96b63 \
+    --hash=sha256:a11299394e101569a62ab061375260d08bc56cd33d685b7067d85312368f4457
+    # via setuptools-scm
+ziglang==0.16.0 \
+    --hash=sha256:089a16a4eb5a2f45151993342f8fabad24ff1a0723dc146642895c29208a3939 \
+    --hash=sha256:0fd671c599f6961638cc302cf1f9461486696385311d4c0276171dcf7d2b67f5 \
+    --hash=sha256:18e14f6b25678d7b7c65708c82501ee6090fe39ed5c783477d56267af1fa5629 \
+    --hash=sha256:7249779f0f916cfd2d1a9d54eb7600f3901384dc8dcbe1eea226bd32a8237fb5 \
+    --hash=sha256:8b83661247430aa335b3cbc29569084900412dde5633b02c80a6d2ff734de3d2 \
+    --hash=sha256:9fcda73f62b851dd72a54b710ad40a209896db14cfb13649e62191243556342b \
+    --hash=sha256:b61e5413c49508d9d62e5dcea543e3af491594154d74a00ff52f84ed508260cc \
+    --hash=sha256:d4bd8197344fffe276e1d6446e4ef7bc38637d821b4685fe96a936503d4b0619 \
+    --hash=sha256:df0e6599e41d087c912b0d3d7cedef6c9cb1f0032465c8fc820e9986772d11e4 \
+    --hash=sha256:e27d409812b11e0fb89ed0200cf2e55b6464d43f9461553104e4a4f9a94a1fd5 \
+    --hash=sha256:e44a5271f7b72f7980017bb615823ed52e765f96b6482d93a2fd338cd53101bf \
+    --hash=sha256:f978c12b5337cf418034964de00023b7ec5ec484383dc97c6a6585f4a9105840

check_symlinks-0.6.0/cli/cli.go

@@ -0,0 +1,126 @@
+// Package cli implements check-symlinks: a recursive check for broken
+// symbolic links.
+//
+// The package is written in the Solod subset of Go, so it builds with both
+// toolchains. `so build` translates it to C for the release binaries; a plain
+// `go build` resolves solod.dev to the gocompat/ shims (see the root go.mod)
+// and produces an equivalent binary with no C compiler in sight.
+package cli
+
+import (
+	"solod.dev/so/conc"
+	"solod.dev/so/flag"
+	"solod.dev/so/fmt"
+	"solod.dev/so/mem"
+	"solod.dev/so/os"
+	"solod.dev/so/runtime"
+	"solod.dev/so/slices"
+	"solod.dev/so/strings"
+)
+
+// Version is the release version. Solod has no ldflags-style stamping, so
+// this constant is the single source of truth; scripts/check-version.sh
+// guards it against the pushed tag.
+const Version = "0.6.0"
+
+// defaultRoots is used when no paths are given on the command line.
+var defaultRoots = [1]string{"."}
+
+// Run checks the given paths and returns the process exit code:
+// 0 if every symlink resolves, 1 if any is broken, 2 on a usage error.
+func Run(args []string) int {
+	var st state
+	st.mu.Init()
+	st.cond.Init(&st.mu)
+	defer st.mu.Free()
+	defer st.cond.Free()
+
+	var noIgnore bool
+	var showVersion bool
+	var threads int
+	fs := flag.NewFlagSet("check-symlinks", flag.ContinueOnError)
+	fs.BoolVar(&st.includeHidden, "hidden", false, "include hidden files and directories in the check")
+	fs.BoolVar(&noIgnore, "no-ignore", false, "don't use ignore files")
+	fs.BoolVar(&st.debug, "debug", false, "run in debug mode")
+	fs.BoolVar(&st.quiet, "quiet", false, "run in quiet mode")
+	fs.BoolVar(&st.quiet, "q", false, "run in quiet mode")
+	fs.IntVar(&threads, "threads", 0, "number of worker threads (0 = one per CPU)")
+	fs.BoolVar(&showVersion, "version", false, "print the version and exit")
+	if err := fs.Parse(args[1:]); err != nil {
+		if err == flag.ErrHelp {
+			return 0
+		}
+		return 2
+	}
+	if showVersion {
+		fmt.Printf("check-symlinks %s\n", Version)
+		return 0
+	}
+
+	// cwdBuf backs both the working directory and the top-level path sliced
+	// out of it, so it has to outlive the walk.
+	var cwdBuf [os.MaxPathLen]byte
+	cwd, err := os.Getwd(cwdBuf[:])
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: cannot get working directory\n")
+		return 2
+	}
+	st.topLevel = findTopLevel(cwd)
+	if st.topLevel == "" && !st.quiet {
+		fmt.Fprintf(os.Stderr, "Failed to find toplevel directory: not a git repository\n")
+	}
+	if !noIgnore && st.topLevel != "" {
+		loadIgnorePatterns(&st)
+	}
+	defer freePatterns(&st)
+
+	roots := fs.Args()
+	if len(roots) == 0 {
+		roots = defaultRoots[:]
+	}
+	// Seed the work stack. A root that is not a directory is checked
+	// directly, without the hidden and ignore filters; a directory root goes
+	// through the same filters as any other entry.
+	for i := range roots {
+		root := roots[i]
+		fi, serr := os.Stat(root)
+		if serr != nil || !fi.IsDir() {
+			st.checked.Add(1)
+			checkOne(&st, root)
+			continue
+		}
+		if !st.includeHidden && isHidden(baseName(root)) {
+			continue
+		}
+		if shouldIgnore(&st, root) {
+			continue
+		}
+		st.checked.Add(1)
+		st.stack = slices.Append(mem.System, st.stack, strings.Clone(mem.System, root))
+	}
+
+	if threads <= 0 {
+		threads = runtime.NumCPU()
+	}
+	if threads == 1 {
+		// Single-threaded: run the worker loop on the main thread.
+		work(&st)
+	} else {
+		ths := make([]conc.Thread, threads)
+		for i := 0; i < threads; i++ {
+			ths[i] = conc.Go(workEntry, &st)
+		}
+		for i := 0; i < threads; i++ {
+			ths[i].Wait()
+		}
+	}
+	slices.Free(mem.System, st.stack)
+
+	if !st.quiet {
+		fmt.Printf("Total files checked: %d\n", st.checked.Load())
+	}
+	if st.broken.Load() {
+		return 1
+	}
+	return 0
+}

check_symlinks-0.6.0/cli/ignore.go

@@ -0,0 +1,81 @@
+package cli
+
+import (
+	"solod.dev/so/bufio"
+	"solod.dev/so/fmt"
+	"solod.dev/so/mem"
+	"solod.dev/so/os"
+	"solod.dev/so/slices"
+	"solod.dev/so/strings"
+)
+
+// shouldIgnore reports whether a path matches any ignore pattern.
+func shouldIgnore(st *state, p string) bool {
+	if len(st.patterns) == 0 {
+		return false
+	}
+	rel := relTo(st.topLevel, p)
+	base := baseName(rel)
+	for i := range st.patterns {
+		pat := strings.TrimSuffix(st.patterns[i], "/")
+		if strings.HasPrefix(rel, pat) || base == pat {
+			return true
+		}
+	}
+	return false
+}
+
+// relTo strips the top-level prefix from an absolute path.
+func relTo(top string, p string) string {
+	if top == "" || len(p) <= len(top) {
+		return p
+	}
+	if strings.HasPrefix(p, top) && p[len(top)] == '/' {
+		return p[len(top)+1:]
+	}
+	return p
+}
+
+// loadIgnorePatterns loads patterns from .symlinkignore or
+// .config/symlinkignore under the top-level directory.
+func loadIgnorePatterns(st *state) {
+	var buf [os.MaxPathLen]byte
+	p := joinPath(buf[:], st.topLevel, ".symlinkignore")
+	if loadPatternsFromFile(st, p) {
+		return
+	}
+	p = joinPath(buf[:], st.topLevel, ".config/symlinkignore")
+	loadPatternsFromFile(st, p)
+}
+
+// loadPatternsFromFile reads patterns from a file, one per line, and reports
+// whether it found any.
+func loadPatternsFromFile(st *state, name string) bool {
+	f, err := os.Open(name)
+	if err != nil {
+		return false
+	}
+	defer f.Close()
+
+	sc := bufio.NewScanner(mem.System, &f)
+	defer sc.Free()
+	for sc.Scan() {
+		line := strings.TrimSpace(sc.Text())
+		if line == "" || line[0] == '#' {
+			continue
+		}
+		st.patterns = slices.Append(mem.System, st.patterns, strings.Clone(mem.System, line))
+	}
+	if st.debug && len(st.patterns) > 0 {
+		fmt.Printf("Found ignore file: %s\n", name)
+	}
+	return len(st.patterns) > 0
+}
+
+// freePatterns releases the ignore patterns.
+func freePatterns(st *state) {
+	for i := range st.patterns {
+		mem.FreeString(mem.System, st.patterns[i])
+	}
+	slices.Free(mem.System, st.patterns)
+}

check_symlinks-0.6.0/cli/path.go

@@ -0,0 +1,60 @@
+package cli
+
+import (
+	"solod.dev/so/os"
+)
+
+// joinPath writes dir + "/" + name into buf and returns it as a string view.
+// The result is only valid until the next call with the same buffer.
+func joinPath(buf []byte, dir string, name string) string {
+	n := copy(buf, dir)
+	if n > 0 && buf[n-1] != '/' && n < len(buf) {
+		buf[n] = '/'
+		n++
+	}
+	n += copy(buf[n:], name)
+	return string(buf[:n])
+}
+
+// isHidden reports whether a path element is hidden.
+func isHidden(name string) bool {
+	return len(name) > 0 && name[0] == '.' && name != "." && name != ".."
+}
+
+// baseName returns the last element of a slash-separated path.
+func baseName(p string) string {
+	i := lastSlash(p)
+	if i < 0 {
+		return p
+	}
+	return p[i+1:]
+}
+
+// lastSlash returns the index of the last '/' in p, or -1.
+func lastSlash(p string) int {
+	for i := len(p) - 1; i >= 0; i-- {
+		if p[i] == '/' {
+			return i
+		}
+	}
+	return -1
+}
+
+// findTopLevel walks up from start looking for a .git directory.
+// The result is a view into start.
+func findTopLevel(start string) string {
+	var buf [os.MaxPathLen]byte
+	dir := start
+	for {
+		p := joinPath(buf[:], dir, ".git")
+		fi, err := os.Stat(p)
+		if err == nil && fi.IsDir() {
+			return dir
+		}
+		i := lastSlash(dir)
+		if i <= 0 {
+			return ""
+		}
+		dir = dir[:i]
+	}
+}