main
1package main
2
3import (
4 "context"
5 "fmt"
6 "os"
7 "path/filepath"
8 "runtime"
9 "sort"
10 "strings"
11 "sync"
12
13 "github.com/antonmedv/gitmal/pkg/git"
14 "github.com/antonmedv/gitmal/pkg/links"
15 "github.com/antonmedv/gitmal/pkg/progress_bar"
16 "github.com/antonmedv/gitmal/pkg/templates"
17)
18
19func generateLists(files []git.Blob, params Params) error {
20 // Build directory indexes
21 type dirInfo struct {
22 subdirs map[string]struct{}
23 files []git.Blob
24 }
25 dirs := map[string]*dirInfo{}
26
27 ensureDir := func(p string) *dirInfo {
28 if di, ok := dirs[p]; ok {
29 return di
30 }
31 di := &dirInfo{subdirs: map[string]struct{}{}, files: []git.Blob{}}
32 dirs[p] = di
33 return di
34 }
35
36 dirsSet := links.BuildDirSet(files)
37 filesSet := links.BuildFileSet(files)
38
39 for _, b := range files {
40 // Normalize to forward slash paths for URL construction
41 p := b.Path
42 parts := strings.Split(p, "/")
43 // walk directories
44 cur := ""
45 for i := 0; i < len(parts)-1; i++ {
46 child := parts[i]
47 ensureDir(cur).subdirs[child] = struct{}{}
48 if cur == "" {
49 cur = child
50 } else {
51 cur = cur + "/" + child
52 }
53 ensureDir(cur) // ensure it exists
54 }
55 ensureDir(cur).files = append(ensureDir(cur).files, b)
56 }
57
58 // Prepare jobs slice to have stable iteration order (optional)
59 type job struct {
60 dirPath string
61 di *dirInfo
62 }
63 jobsSlice := make([]job, 0, len(dirs))
64 for dp, di := range dirs {
65 jobsSlice = append(jobsSlice, job{dirPath: dp, di: di})
66 }
67 // Sort by dirPath for determinism
68 sort.Slice(jobsSlice, func(i, j int) bool { return jobsSlice[i].dirPath < jobsSlice[j].dirPath })
69
70 // Worker pool similar to generateBlobs
71 workers := runtime.NumCPU()
72 if workers < 1 {
73 workers = 1
74 }
75
76 ctx, cancel := context.WithCancel(context.Background())
77 defer cancel()
78
79 jobCh := make(chan job)
80 errCh := make(chan error, 1)
81 var wg sync.WaitGroup
82
83 p := progress_bar.NewProgressBar("lists for "+params.Ref.String(), len(jobsSlice))
84
85 check := func(err error) bool {
86 if err != nil {
87 select {
88 case errCh <- err:
89 cancel()
90 default:
91 }
92 return true
93 }
94 return false
95 }
96
97 workerFn := func() {
98 defer wg.Done()
99 for {
100 select {
101 case <-ctx.Done():
102 return
103 case jb, ok := <-jobCh:
104 if !ok {
105 return
106 }
107 func() {
108 dirPath := jb.dirPath
109 di := jb.di
110
111 outDir := filepath.Join(params.OutputDir, "blob", params.Ref.DirName())
112 if dirPath != "" {
113 // convert forward slash path into OS path
114 outDir = filepath.Join(outDir, filepath.FromSlash(dirPath))
115 }
116 if err := os.MkdirAll(outDir, 0o755); check(err) {
117 return
118 }
119
120 // Build entries
121 dirNames := make([]string, 0, len(di.subdirs))
122 for name := range di.subdirs {
123 dirNames = append(dirNames, name)
124 }
125
126 // Sort for stable output
127 sort.Strings(dirNames)
128 sort.Slice(di.files, func(i, j int) bool {
129 return di.files[i].FileName < di.files[j].FileName
130 })
131
132 subdirEntries := make([]templates.ListEntry, 0, len(dirNames))
133 for _, name := range dirNames {
134 subdirEntries = append(subdirEntries, templates.ListEntry{
135 Name: name + "/",
136 Href: name + "/index.html",
137 IsDir: true,
138 })
139 }
140
141 fileEntries := make([]templates.ListEntry, 0, len(di.files))
142 for _, b := range di.files {
143 fileEntries = append(fileEntries, templates.ListEntry{
144 Name: b.FileName + "",
145 Href: b.FileName + ".html",
146 Mode: b.Mode,
147 Size: humanizeSize(b.Size),
148 })
149 }
150
151 // Title and current path label
152 title := fmt.Sprintf("%s/%s at %s", params.Name, dirPath, params.Ref)
153 if dirPath == "" {
154 title = fmt.Sprintf("%s at %s", params.Name, params.Ref)
155 }
156
157 f, err := os.Create(filepath.Join(outDir, "index.html"))
158 if check(err) {
159 return
160 }
161 defer func() {
162 _ = f.Close()
163 }()
164
165 // parent link is not shown for root
166 parent := "../index.html"
167 if dirPath == "" {
168 parent = ""
169 }
170
171 depth := 0
172 if dirPath != "" {
173 depth = len(strings.Split(dirPath, "/"))
174 }
175 rootHref := strings.Repeat("../", depth+2)
176
177 readmeHTML := readme(di.files, dirsSet, filesSet, params, rootHref)
178
179 err = templates.ListTemplate.ExecuteTemplate(f, "layout.gohtml", templates.ListParams{
180 LayoutParams: templates.LayoutParams{
181 Title: title,
182 Name: params.Name,
183 RootHref: rootHref,
184 CurrentRefDir: params.Ref.DirName(),
185 Selected: "code",
186 AssetNames: params.AssetNames,
187 },
188 HeaderParams: templates.HeaderParams{
189 Ref: params.Ref,
190 Breadcrumbs: breadcrumbs(params.Name, dirPath, false),
191 },
192 Ref: params.Ref,
193 ParentHref: parent,
194 Dirs: subdirEntries,
195 Files: fileEntries,
196 Readme: readmeHTML,
197 })
198 if check(err) {
199 return
200 }
201 }()
202
203 p.Inc()
204 }
205 }
206 }
207
208 // Start workers
209 wg.Add(workers)
210 for i := 0; i < workers; i++ {
211 go workerFn()
212 }
213
214 // Feed jobs
215 go func() {
216 defer close(jobCh)
217 for _, jb := range jobsSlice {
218 select {
219 case <-ctx.Done():
220 return
221 case jobCh <- jb:
222 }
223 }
224 }()
225
226 // Wait for workers or first error
227 doneCh := make(chan struct{})
228 go func() {
229 wg.Wait()
230 close(doneCh)
231 }()
232
233 var runErr error
234 select {
235 case runErr = <-errCh:
236 <-doneCh
237 case <-doneCh:
238 }
239
240 p.Done()
241
242 return runErr
243}