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}