Make branch safe dir names

blob.go

@@ -57,7 +57,7 @@ func generateBlobs(files []git.Blob, params Params) error {
 	errCh := make(chan error, 1)
 	var wg sync.WaitGroup
 
-	p := progress_bar.NewProgressBar("blobs for "+string(params.Ref), len(files))
+	p := progress_bar.NewProgressBar("blobs for "+params.Ref.String(), len(files))
 
 	workerFn := func() {
 		defer wg.Done()
@@ -98,7 +98,7 @@ func generateBlobs(files []git.Blob, params Params) error {
 						content = string(data)
 					}
 
-					outPath := filepath.Join(params.OutputDir, "blob", string(params.Ref), blob.Path) + ".html"
+					outPath := filepath.Join(params.OutputDir, "blob", params.Ref.DirName(), blob.Path) + ".html"
 					if err := os.MkdirAll(filepath.Dir(outPath), 0o755); check(err) {
 						return
 					}
@@ -127,20 +127,20 @@ func generateBlobs(files []git.Blob, params Params) error {
 							b.String(),
 							blob.Path,
 							rootHref,
-							string(params.Ref),
+							params.Ref.DirName(),
 							dirsSet,
 							filesSet,
 						)
 
 						err = templates.MarkdownTemplate.ExecuteTemplate(f, "layout.gohtml", templates.MarkdownParams{
 							LayoutParams: templates.LayoutParams{
-								Title:       fmt.Sprintf("%s/%s at %s", params.Name, blob.Path, params.Ref),
-								Dark:        params.Dark,
-								CSSMarkdown: cssMarkdown(params.Dark),
-								Name:        params.Name,
-								RootHref:    rootHref,
-								CurrentRef:  params.Ref,
-								Selected:    "code",
+								Title:         fmt.Sprintf("%s/%s at %s", params.Name, blob.Path, params.Ref),
+								Dark:          params.Dark,
+								CSSMarkdown:   cssMarkdown(params.Dark),
+								Name:          params.Name,
+								RootHref:      rootHref,
+								CurrentRefDir: params.Ref.DirName(),
+								Selected:      "code",
 							},
 							HeaderParams: templates.HeaderParams{
 								Ref:         params.Ref,
@@ -170,7 +170,7 @@ func generateBlobs(files []git.Blob, params Params) error {
 
 						} else if isImg {
 
-							rawPath := filepath.Join(params.OutputDir, "raw", string(params.Ref), blob.Path)
+							rawPath := filepath.Join(params.OutputDir, "raw", params.Ref.DirName(), blob.Path)
 							if err := os.MkdirAll(filepath.Dir(rawPath), 0o755); check(err) {
 								return
 							}
@@ -187,18 +187,18 @@ func generateBlobs(files []git.Blob, params Params) error {
 								return
 							}
 
-							relativeRawPath := filepath.Join(rootHref, "raw", string(params.Ref), blob.Path)
+							relativeRawPath := filepath.Join(rootHref, "raw", params.Ref.DirName(), blob.Path)
 							contentHTML = template.HTML(fmt.Sprintf(`<img src="%s" alt="%s" />`, relativeRawPath, blob.FileName))
 						}
 
 						err = templates.BlobTemplate.ExecuteTemplate(f, "layout.gohtml", templates.BlobParams{
 							LayoutParams: templates.LayoutParams{
-								Title:      fmt.Sprintf("%s/%s at %s", params.Name, blob.Path, params.Ref),
-								Dark:       params.Dark,
-								Name:       params.Name,
-								RootHref:   rootHref,
-								CurrentRef: params.Ref,
-								Selected:   "code",
+								Title:         fmt.Sprintf("%s/%s at %s", params.Name, blob.Path, params.Ref),
+								Dark:          params.Dark,
+								Name:          params.Name,
+								RootHref:      rootHref,
+								CurrentRefDir: params.Ref.DirName(),
+								Selected:      "code",
 							},
 							HeaderParams: templates.HeaderParams{
 								Ref:         params.Ref,

branches.go

@@ -21,10 +21,10 @@ func generateBranches(branches []git.Ref, defaultBranch string, params Params) e
 	entries := make([]templates.BranchEntry, 0, len(branches))
 	for _, b := range branches {
 		entries = append(entries, templates.BranchEntry{
-			Name:        string(b),
-			Href:        filepath.ToSlash(filepath.Join("blob", string(b)) + "/index.html"),
-			IsDefault:   string(b) == defaultBranch,
-			CommitsHref: filepath.ToSlash(filepath.Join("commits", string(b), "index.html")),
+			Name:        b.String(),
+			Href:        filepath.ToSlash(filepath.Join("blob", b.DirName()) + "/index.html"),
+			IsDefault:   b.String() == defaultBranch,
+			CommitsHref: filepath.ToSlash(filepath.Join("commits", b.DirName(), "index.html")),
 		})
 	}
 
@@ -48,12 +48,12 @@ func generateBranches(branches []git.Ref, defaultBranch string, params Params) e
 
 	err = templates.BranchesTemplate.ExecuteTemplate(f, "layout.gohtml", templates.BranchesParams{
 		LayoutParams: templates.LayoutParams{
-			Title:      fmt.Sprintf("Branches %s %s", dot, params.Name),
-			Name:       params.Name,
-			Dark:       params.Dark,
-			RootHref:   rootHref,
-			CurrentRef: params.DefaultRef,
-			Selected:   "branches",
+			Title:         fmt.Sprintf("Branches %s %s", dot, params.Name),
+			Name:          params.Name,
+			Dark:          params.Dark,
+			RootHref:      rootHref,
+			CurrentRefDir: params.DefaultRef.DirName(),
+			Selected:      "branches",
 		},
 		Branches: entries,
 	})

commit.go

@@ -230,18 +230,18 @@ func generateCommitPage(commit git.Commit, params Params) error {
 	})
 
 	currentRef := params.DefaultRef
-	if commit.Branch != "" {
+	if !commit.Branch.IsEmpty() {
 		currentRef = commit.Branch
 	}
 
 	err = templates.CommitTemplate.ExecuteTemplate(f, "layout.gohtml", templates.CommitParams{
 		LayoutParams: templates.LayoutParams{
-			Title:      fmt.Sprintf("%s %s %s@%s", commit.Subject, dot, params.Name, commit.ShortHash),
-			Name:       params.Name,
-			Dark:       params.Dark,
-			RootHref:   rootHref,
-			CurrentRef: currentRef,
-			Selected:   "commits",
+			Title:         fmt.Sprintf("%s %s %s@%s", commit.Subject, dot, params.Name, commit.ShortHash),
+			Name:          params.Name,
+			Dark:          params.Dark,
+			RootHref:      rootHref,
+			CurrentRefDir: currentRef.DirName(),
+			Selected:      "commits",
 		},
 		Commit:    commit,
 		DiffCSS:   template.CSS(cssBuf.String()),

commits_list.go

@@ -19,12 +19,12 @@ func generateLogForBranch(allCommits []git.Commit, params Params) error {
 
 	// RootHref from commits/<branch>/... => ../../
 	rootHref := "../../"
-	outBase := filepath.Join(params.OutputDir, "commits", string(params.Ref))
+	outBase := filepath.Join(params.OutputDir, "commits", params.Ref.DirName())
 	if err := os.MkdirAll(outBase, 0o755); err != nil {
 		return err
 	}
 
-	p := progress_bar.NewProgressBar("commits for "+string(params.Ref), totalPages)
+	p := progress_bar.NewProgressBar("commits for "+params.Ref.String(), totalPages)
 
 	page := 1
 	for pageCommits := range slices.Chunk(allCommits, commitsPerPage) {
@@ -62,12 +62,12 @@ func generateLogForBranch(allCommits []git.Commit, params Params) error {
 
 		err = templates.CommitsListTemplate.ExecuteTemplate(f, "layout.gohtml", templates.CommitsListParams{
 			LayoutParams: templates.LayoutParams{
-				Title:      fmt.Sprintf("Commits %s %s", dot, params.Name),
-				Name:       params.Name,
-				Dark:       params.Dark,
-				RootHref:   rootHref,
-				CurrentRef: params.Ref,
-				Selected:   "commits",
+				Title:         fmt.Sprintf("Commits %s %s", dot, params.Name),
+				Name:          params.Name,
+				Dark:          params.Dark,
+				RootHref:      rootHref,
+				CurrentRefDir: params.Ref.DirName(),
+				Selected:      "commits",
 			},
 			HeaderParams: templates.HeaderParams{
 				Header: "Commits",

index.go

@@ -72,7 +72,7 @@ func generateIndex(files []git.Blob, params Params) error {
 	for _, name := range dirNames {
 		subdirEntries = append(subdirEntries, templates.ListEntry{
 			Name:  name + "/",
-			Href:  "blob/" + string(params.Ref) + "/" + name + "/index.html",
+			Href:  "blob/" + params.Ref.DirName() + "/" + name + "/index.html",
 			IsDir: true,
 		})
 	}
@@ -81,7 +81,7 @@ func generateIndex(files []git.Blob, params Params) error {
 	for _, b := range di.files {
 		fileEntries = append(fileEntries, templates.ListEntry{
 			Name: b.FileName + "",
-			Href: "blob/" + string(params.Ref) + "/" + b.FileName + ".html",
+			Href: "blob/" + params.Ref.DirName() + "/" + b.FileName + ".html",
 			Mode: b.Mode,
 			Size: humanizeSize(b.Size),
 		})
@@ -100,13 +100,13 @@ func generateIndex(files []git.Blob, params Params) error {
 
 	err = templates.ListTemplate.ExecuteTemplate(f, "layout.gohtml", templates.ListParams{
 		LayoutParams: templates.LayoutParams{
-			Title:       title,
-			Name:        params.Name,
-			Dark:        params.Dark,
-			CSSMarkdown: cssMarkdown(params.Dark),
-			RootHref:    rootHref,
-			CurrentRef:  params.Ref,
-			Selected:    "code",
+			Title:         title,
+			Name:          params.Name,
+			Dark:          params.Dark,
+			CSSMarkdown:   cssMarkdown(params.Dark),
+			RootHref:      rootHref,
+			CurrentRefDir: params.Ref.DirName(),
+			Selected:      "code",
 		},
 		HeaderParams: templates.HeaderParams{
 			Ref:         params.Ref,

list.go

@@ -81,7 +81,7 @@ func generateLists(files []git.Blob, params Params) error {
 	errCh := make(chan error, 1)
 	var wg sync.WaitGroup
 
-	p := progress_bar.NewProgressBar("lists for "+string(params.Ref), len(jobsSlice))
+	p := progress_bar.NewProgressBar("lists for "+params.Ref.String(), len(jobsSlice))
 
 	check := func(err error) bool {
 		if err != nil {
@@ -109,7 +109,7 @@ func generateLists(files []git.Blob, params Params) error {
 					dirPath := jb.dirPath
 					di := jb.di
 
-					outDir := filepath.Join(params.OutputDir, "blob", string(params.Ref))
+					outDir := filepath.Join(params.OutputDir, "blob", params.Ref.DirName())
 					if dirPath != "" {
 						// convert forward slash path into OS path
 						outDir = filepath.Join(outDir, filepath.FromSlash(dirPath))
@@ -183,13 +183,13 @@ func generateLists(files []git.Blob, params Params) error {
 
 					err = templates.ListTemplate.ExecuteTemplate(f, "layout.gohtml", templates.ListParams{
 						LayoutParams: templates.LayoutParams{
-							Title:       title,
-							Name:        params.Name,
-							Dark:        params.Dark,
-							CSSMarkdown: CSSMarkdown,
-							RootHref:    rootHref,
-							CurrentRef:  params.Ref,
-							Selected:    "code",
+							Title:         title,
+							Name:          params.Name,
+							Dark:          params.Dark,
+							CSSMarkdown:   CSSMarkdown,
+							RootHref:      rootHref,
+							CurrentRefDir: params.Ref.DirName(),
+							Selected:      "code",
 						},
 						HeaderParams: templates.HeaderParams{
 							Ref:         params.Ref,

main.go

@@ -135,6 +135,11 @@ func main() {
 		os.Exit(1)
 	}
 
+	if yes, a, b := hasConflictingBranchNames(branches); yes {
+		echo(fmt.Sprintf("Conflicting branchs %q and %q, both want to use %q dir name.", a, b, a.DirName()))
+		os.Exit(1)
+	}
+
 	// Start generating pages
 
 	params := Params{
@@ -144,7 +149,7 @@ func main() {
 		OutputDir:  outputDir,
 		Style:      flagTheme,
 		Dark:       themeColor == "dark",
-		DefaultRef: git.Ref(flagDefaultBranch),
+		DefaultRef: git.NewRef(flagDefaultBranch),
 	}
 
 	commits := make(map[string]git.Commit)
@@ -165,13 +170,15 @@ func main() {
 		}
 	}
 
+	// Add commits from tags
 	for _, tag := range tags {
-		commitsForTag, err := git.Commits(git.Ref(tag.Name), params.RepoDir)
+		commitsForTag, err := git.Commits(git.NewRef(tag.Name), params.RepoDir)
 		if err != nil {
 			panic(err)
 		}
 		for _, commit := range commitsForTag {
-			if alreadyExisting, ok := commits[commit.Hash]; ok && alreadyExisting.Branch != "" {
+			// Only add new commits
+			if alreadyExisting, ok := commits[commit.Hash]; ok && !alreadyExisting.Branch.IsEmpty() {
 				continue
 			}
 			commits[commit.Hash] = commit
@@ -196,7 +203,7 @@ func main() {
 				panic(err)
 			}
 
-			if branch == git.Ref(flagDefaultBranch) {
+			if branch.String() == flagDefaultBranch {
 				defaultBranchFiles = files
 			}
 
@@ -220,7 +227,7 @@ func main() {
 	}
 
 	// Back to the default branch
-	params.Ref = git.Ref(flagDefaultBranch)
+	params.Ref = git.NewRef(flagDefaultBranch)
 
 	// Commits pages generation
 	echo("> generating commits...")

pkg/git/git.go

@@ -31,7 +31,7 @@ func Branches(repoDir string, filter *regexp.Regexp, defaultBranch string) ([]Re
 		if filter != nil && !filter.MatchString(line) && line != defaultBranch {
 			continue
 		}
-		branches = append(branches, Ref(line))
+		branches = append(branches, NewRef(line))
 	}
 	return branches, nil
 }
@@ -88,13 +88,13 @@ func Tags(repoDir string) ([]Tag, error) {
 }
 
 func Files(ref Ref, repoDir string) ([]Blob, error) {
-	if ref == "" {
-		ref = "HEAD"
+	if ref.IsEmpty() {
+		ref = NewRef("HEAD")
 	}
 
 	// -r: recurse into subtrees
 	// -l: include blob size
-	cmd := exec.Command("git", "ls-tree", "--full-tree", "-r", "-l", string(ref))
+	cmd := exec.Command("git", "ls-tree", "--full-tree", "-r", "-l", ref.String())
 	if repoDir != "" {
 		cmd.Dir = repoDir
 	}
@@ -196,11 +196,11 @@ func Files(ref Ref, repoDir string) ([]Blob, error) {
 }
 
 func BlobContent(ref Ref, path string, repoDir string) ([]byte, bool, error) {
-	if ref == "" {
-		ref = "HEAD"
+	if ref.IsEmpty() {
+		ref = NewRef("HEAD")
 	}
 	// Use `git show ref:path` to get the blob content at that ref
-	cmd := exec.Command("git", "show", string(ref)+":"+path)
+	cmd := exec.Command("git", "show", ref.String()+":"+path)
 	if repoDir != "" {
 		cmd.Dir = repoDir
 	}
@@ -233,7 +233,7 @@ func Commits(ref Ref, repoDir string) ([]Commit, error) {
 		"--date=unix",
 		"--pretty=format:" + strings.Join(format, "\x1F"),
 		"-z", // Separate the commits with NULs instead of newlines
-		string(ref),
+		ref.String(),
 	}
 
 	cmd := exec.Command("git", args...)

pkg/git/types.go

@@ -4,7 +4,29 @@ import (
 	"time"
 )
 
-type Ref string
+type Ref struct {
+	ref     string
+	dirName string
+}
+
+func NewRef(ref string) Ref {
+	return Ref{
+		ref:     ref,
+		dirName: RefToFileName(ref),
+	}
+}
+
+func (r Ref) IsEmpty() bool {
+	return r.ref == ""
+}
+
+func (r Ref) String() string {
+	return r.ref
+}
+
+func (r Ref) DirName() string {
+	return r.dirName
+}
 
 type Blob struct {
 	Ref      Ref