git.iko.soy/crush
on 94de6bc help sign in
crush/internal/fsext/ls.go
253 lines 5.8 kB history raw
1package fsext
3import (
4 "errors"
5 "log/slog"
6 "os"
7 "path/filepath"
8 "slices"
9 "strings"
10 "sync"
12 "github.com/charlievieth/fastwalk"
13 "github.com/charmbracelet/crush/internal/csync"
14 "github.com/charmbracelet/crush/internal/home"
15 ignore "github.com/sabhiram/go-gitignore"
18// commonIgnorePatterns contains commonly ignored files and directories
19var commonIgnorePatterns = sync.OnceValue(func() ignore.IgnoreParser {
20 return ignore.CompileIgnoreLines(
21 // Version control
22 ".git",
23 ".svn",
24 ".hg",
25 ".bzr",
27 // IDE and editor files
28 ".vscode",
29 ".idea",
30 "*.swp",
31 "*.swo",
32 "*~",
33 ".DS_Store",
34 "Thumbs.db",
36 // Build artifacts and dependencies
37 "node_modules",
38 "target",
39 "build",
40 "dist",
41 "out",
42 "bin",
43 "obj",
44 "*.o",
45 "*.so",
46 "*.dylib",
47 "*.dll",
48 "*.exe",
50 // Logs and temporary files
51 "*.log",
52 "*.tmp",
53 "*.temp",
54 ".cache",
55 ".tmp",
57 // Language-specific
58 "__pycache__",
59 "*.pyc",
60 "*.pyo",
61 ".pytest_cache",
62 "vendor",
63 "Cargo.lock",
64 "package-lock.json",
65 "yarn.lock",
66 "pnpm-lock.yaml",
68 // OS generated files
69 ".Trash",
70 ".Spotlight-V100",
71 ".fseventsd",
73 // Crush
74 ".crush",
76 // macOS stuff
77 "OrbStack",
78 ".local",
79 ".share",
80 )
81})
83var homeIgnore = sync.OnceValue(func() ignore.IgnoreParser {
84 home := home.Dir()
85 var lines []string
86 for _, name := range []string{
87 filepath.Join(home, ".gitignore"),
88 filepath.Join(home, ".config", "git", "ignore"),
89 filepath.Join(home, ".config", "crush", "ignore"),
90 } {
91 if bts, err := os.ReadFile(name); err == nil {
92 lines = append(lines, strings.Split(string(bts), "\n")...)
93 }
94 }
95 return ignore.CompileIgnoreLines(lines...)
96})
98type directoryLister struct {
99 ignores *csync.Map[string, ignore.IgnoreParser]
100 rootPath string
103func NewDirectoryLister(rootPath string) *directoryLister {
104 dl := &directoryLister{
105 rootPath: rootPath,
106 ignores: csync.NewMap[string, ignore.IgnoreParser](),
107 }
108 dl.getIgnore(rootPath)
109 return dl
112// git checks, in order:
113// - ./.gitignore, ../.gitignore, etc, until repo root
114// ~/.config/git/ignore
115// ~/.gitignore
116//
117// This will do the following:
118// - the given ignorePatterns
119// - [commonIgnorePatterns]
120// - ./.gitignore, ../.gitignore, etc, until dl.rootPath
121// - ./.crushignore, ../.crushignore, etc, until dl.rootPath
122// ~/.config/git/ignore
123// ~/.gitignore
124// ~/.config/crush/ignore
125func (dl *directoryLister) shouldIgnore(path string, ignorePatterns []string) bool {
126 if len(ignorePatterns) > 0 {
127 base := filepath.Base(path)
128 for _, pattern := range ignorePatterns {
129 if matched, err := filepath.Match(pattern, base); err == nil && matched {
130 return true
131 }
132 }
133 }
135 // Don't apply gitignore rules to the root directory itself
136 // In gitignore semantics, patterns don't apply to the repo root
137 if path == dl.rootPath {
138 return false
139 }
141 relPath, err := filepath.Rel(dl.rootPath, path)
142 if err != nil {
143 relPath = path
144 }
146 if commonIgnorePatterns().MatchesPath(relPath) {
147 slog.Debug("ignoring common pattern", "path", relPath)
148 return true
149 }
151 parentDir := filepath.Dir(path)
152 ignoreParser := dl.getIgnore(parentDir)
153 if ignoreParser.MatchesPath(relPath) {
154 slog.Debug("ignoring dir pattern", "path", relPath, "dir", parentDir)
155 return true
156 }
158 // For directories, also check with trailing slash (gitignore convention)
159 if ignoreParser.MatchesPath(relPath + "/") {
160 slog.Debug("ignoring dir pattern with slash", "path", relPath+"/", "dir", parentDir)
161 return true
162 }
164 if dl.checkParentIgnores(relPath) {
165 return true
166 }
168 if homeIgnore().MatchesPath(relPath) {
169 slog.Debug("ignoring home dir pattern", "path", relPath)
170 return true
171 }
173 return false
176func (dl *directoryLister) checkParentIgnores(path string) bool {
177 parent := filepath.Dir(filepath.Dir(path))
178 for parent != "." && path != "." {
179 if dl.getIgnore(parent).MatchesPath(path) {
180 slog.Debug("ingoring parent dir pattern", "path", path, "dir", parent)
181 return true
182 }
183 if parent == dl.rootPath {
184 break
185 }
186 parent = filepath.Dir(parent)
187 }
188 return false
191func (dl *directoryLister) getIgnore(path string) ignore.IgnoreParser {
192 return dl.ignores.GetOrSet(path, func() ignore.IgnoreParser {
193 var lines []string
194 for _, ign := range []string{".crushignore", ".gitignore"} {
195 name := filepath.Join(path, ign)
196 if content, err := os.ReadFile(name); err == nil {
197 lines = append(lines, strings.Split(string(content), "\n")...)
198 }
199 }
200 if len(lines) == 0 {
201 // Return a no-op parser to avoid nil checks
202 return ignore.CompileIgnoreLines()
203 }
204 return ignore.CompileIgnoreLines(lines...)
205 })
208// ListDirectory lists files and directories in the specified path,
209func ListDirectory(initialPath string, ignorePatterns []string, depth, limit int) ([]string, bool, error) {
210 found := csync.NewSlice[string]()
211 dl := NewDirectoryLister(initialPath)
213 slog.Debug("listing directory", "path", initialPath, "depth", depth, "limit", limit, "ignorePatterns", ignorePatterns)
215 conf := fastwalk.Config{
216 Follow: true,
217 ToSlash: fastwalk.DefaultToSlash(),
218 Sort: fastwalk.SortDirsFirst,
219 MaxDepth: depth,
220 }
222 err := fastwalk.Walk(&conf, initialPath, func(path string, d os.DirEntry, err error) error {
223 if err != nil {
224 return nil // Skip files we don't have permission to access
225 }
227 if dl.shouldIgnore(path, ignorePatterns) {
228 if d.IsDir() {
229 return filepath.SkipDir
230 }
231 return nil
232 }
234 if path != initialPath {
235 if d.IsDir() {
236 path = path + string(filepath.Separator)
237 }
238 found.Append(path)
239 }
241 if limit > 0 && found.Len() >= limit {
242 return filepath.SkipAll
243 }
245 return nil
246 })
247 if err != nil && !errors.Is(err, filepath.SkipAll) {
248 return nil, false, err
249 }
251 matches, truncated := truncate(slices.Collect(found.Seq()), limit)
252 return matches, truncated || errors.Is(err, filepath.SkipAll), nil