fork/gdu

git clone https://git.julia.blue/fork/gdu

Daniel Mildefeat: show bar for item count (#649)daaae96

master
5.2 KiB204 linesraw
1package fs
2
3import (
4	"io"
5	"iter"
6	"time"
7
8	"github.com/maruel/natural"
9)
10
11// SortBy represents the field to sort files by
12type SortBy int
13
14const (
15	SortBySize SortBy = iota
16	SortByName
17	SortByItemCount
18	SortByMtime
19	SortByApparentSize
20)
21
22// SortOrder represents the sort direction
23type SortOrder int
24
25const (
26	SortAsc SortOrder = iota
27	SortDesc
28)
29
30// Item is a FS item (file or dir)
31type Item interface {
32	GetPath() string
33	GetName() string
34	GetFlag() rune
35	IsDir() bool
36	GetSize() int64
37	GetType() string
38	GetUsage() int64
39	GetMtime() time.Time
40	GetItemCount() int64
41	GetParent() Item
42	SetParent(Item)
43	GetMultiLinkedInode() uint64
44	EncodeJSON(writer io.Writer, topLevel bool, attributes JSONAttributes) error
45	GetItemStats(linkedItems HardLinkedItems, filteringFiles bool) (itemCount int64, size, usage int64)
46	UpdateStats(linkedItems HardLinkedItems)
47	UpdateStatsWithFileFiltering(linkedItems HardLinkedItems)
48	AddFile(Item)
49	GetFiles(SortBy, SortOrder) iter.Seq[Item]
50	GetFilesLocked(SortBy, SortOrder) iter.Seq[Item]
51	RemoveFile(Item)
52	RemoveFileByName(name string)
53	RLock() func()
54}
55
56// SymlinkItem is an optional interface implemented by items that carry a
57// symlink target. Consumers type-assert an Item to it to display the target
58// (e.g. "name -> target"); items that are not symlinks return an empty string.
59type SymlinkItem interface {
60	GetSymlinkTarget() string
61}
62
63// Files - slice of pointers to File
64type Files []Item
65
66// HardLinkedItems maps inode number to array of all hard linked items
67type HardLinkedItems map[uint64]Files
68
69// IndexOf searches File in Files and returns its index
70func (f Files) IndexOf(file Item) (int, bool) {
71	for i, item := range f {
72		if item == file {
73			return i, true
74		}
75	}
76	return 0, false
77}
78
79// FindByName searches name in Files and returns its index
80func (f Files) FindByName(name string) (int, bool) {
81	for i, item := range f {
82		if item.GetName() == name {
83			return i, true
84		}
85	}
86	return 0, false
87}
88
89// Remove removes File from Files
90func (f Files) Remove(file Item) Files {
91	index, ok := f.IndexOf(file)
92	if !ok {
93		return f
94	}
95	return append(f[:index], f[index+1:]...)
96}
97
98// RemoveByName removes File from Files
99func (f Files) RemoveByName(name string) Files {
100	index, ok := f.FindByName(name)
101	if !ok {
102		return f
103	}
104	return append(f[:index], f[index+1:]...)
105}
106
107func (f Files) Len() int      { return len(f) }
108func (f Files) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
109func (f Files) Less(i, j int) bool {
110	if f[i].GetUsage() != f[j].GetUsage() {
111		return f[i].GetUsage() < f[j].GetUsage()
112	}
113	// if usage is the same, sort by name
114	return natural.Less(f[i].GetName(), f[j].GetName())
115}
116
117// ByApparentSize sorts files by apparent size
118type ByApparentSize Files
119
120func (f ByApparentSize) Len() int      { return len(f) }
121func (f ByApparentSize) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
122func (f ByApparentSize) Less(i, j int) bool {
123	if f[i].GetSize() != f[j].GetSize() {
124		return f[i].GetSize() < f[j].GetSize()
125	}
126	// if size is the same, sort by name
127	return natural.Less(f[i].GetName(), f[j].GetName())
128}
129
130// DisplayedItemCount returns the item count as it is presented to the user.
131//
132// For a directory it is the number of items contained in its tree, excluding
133// the directory itself (GetItemCount counts the directory too). For a file it
134// is 1, i.e. the file counts itself. The asymmetry is deliberate: a row for a
135// file reports the one file it stands for, while a row for a directory reports
136// what is inside it.
137//
138// This is the authoritative value: it is what every frontend renders and what
139// SortByItemCount orders by, so the number on screen and the ordering always
140// agree.
141func DisplayedItemCount(item Item) int64 {
142	if item.IsDir() {
143		return item.GetItemCount() - 1
144	}
145	return item.GetItemCount()
146}
147
148// ByItemCount sorts files by item count
149type ByItemCount Files
150
151func (f ByItemCount) Len() int      { return len(f) }
152func (f ByItemCount) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
153func (f ByItemCount) Less(i, j int) bool {
154	ci, cj := DisplayedItemCount(f[i]), DisplayedItemCount(f[j])
155	if ci != cj {
156		return ci < cj
157	}
158	// if item count is the same, sort by name
159	return natural.Less(f[i].GetName(), f[j].GetName())
160}
161
162// ByName sorts files by name
163type ByName Files
164
165func (f ByName) Len() int           { return len(f) }
166func (f ByName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
167func (f ByName) Less(i, j int) bool { return natural.Less(f[i].GetName(), f[j].GetName()) }
168
169// ByMtime sorts files by name
170type ByMtime Files
171
172func (f ByMtime) Len() int      { return len(f) }
173func (f ByMtime) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
174func (f ByMtime) Less(i, j int) bool {
175	if !f[i].GetMtime().Equal(f[j].GetMtime()) {
176		return f[i].GetMtime().Before(f[j].GetMtime())
177	}
178	// if item count is the same, sort by name
179	return natural.Less(f[i].GetName(), f[j].GetName())
180}
181
182// ParseSortBy converts a string to SortBy
183func ParseSortBy(s string) SortBy {
184	switch s {
185	case "name":
186		return SortByName
187	case "size":
188		return SortBySize
189	case "itemCount":
190		return SortByItemCount
191	case "mtime":
192		return SortByMtime
193	default:
194		return SortBySize
195	}
196}
197
198// ParseSortOrder converts a string to SortOrder
199func ParseSortOrder(s string) SortOrder {
200	if s == "asc" {
201		return SortAsc
202	}
203	return SortDesc
204}