helpers: Remove unused code

common/paths/path.go

@@ -188,23 +188,6 @@ func extractFilename(in, ext, base, pathSeparator string) (name string) {
 	return
 }
 
-func prettifyPath(in string, b filepathPathBridge) string {
-	if filepath.Ext(in) == "" {
-		// /section/name/  -> /section/name/index.html
-		if len(in) < 2 {
-			return b.Separator()
-		}
-		return b.Join(in, "index.html")
-	}
-	name, ext := fileAndExt(in, b)
-	if name == "index" {
-		// /section/name/index.html -> /section/name/index.html
-		return b.Clean(in)
-	}
-	// /section/name.html -> /section/name/index.html
-	return b.Join(b.Dir(in), name, "index"+ext)
-}
-
 // Sanitize sanitizes string to be used in Hugo's file paths and URLs, allowing only
 // a predefined set of special Unicode characters.
 //

helpers/general.go

@@ -14,7 +14,6 @@
 package helpers
 
 import (
-	"bytes"
 	"fmt"
 	"io"
 	"net"
@@ -85,41 +84,6 @@ func ReaderToString(lines io.Reader) string {
 	return b.String()
 }
 
-// ReaderContains reports whether subslice is within r.
-func ReaderContains(r io.Reader, subslice []byte) bool {
-	if r == nil || len(subslice) == 0 {
-		return false
-	}
-
-	bufflen := len(subslice) * 4
-	halflen := bufflen / 2
-	buff := make([]byte, bufflen)
-	var err error
-	var n, i int
-
-	for {
-		i++
-		if i == 1 {
-			n, err = io.ReadAtLeast(r, buff[:halflen], halflen)
-		} else {
-			if i != 2 {
-				// shift left to catch overlapping matches
-				copy(buff[:], buff[halflen:])
-			}
-			n, err = io.ReadAtLeast(r, buff[halflen:], halflen)
-		}
-
-		if n > 0 && bytes.Contains(buff, subslice) {
-			return true
-		}
-
-		if err != nil {
-			break
-		}
-	}
-	return false
-}
-
 // GetTitleFunc returns a func that can be used to transform a string to
 // title case.
 //

helpers/general_test.go

@@ -14,7 +14,6 @@
 package helpers_test
 
 import (
-	"strings"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
@@ -106,64 +105,6 @@ func TestHasStringsSuffix(t *testing.T) {
 	}
 }
 
-var containsTestText = (`На берегу пустынных волн
-Стоял он, дум великих полн,
-И вдаль глядел. Пред ним широко
-Река неслася; бедный чёлн
-По ней стремился одиноко.
-По мшистым, топким берегам
-Чернели избы здесь и там,
-Приют убогого чухонца;
-И лес, неведомый лучам
-В тумане спрятанного солнца,
-Кругом шумел.
-
-Τη γλώσσα μου έδωσαν ελληνική
-το σπίτι φτωχικό στις αμμουδιές του Ομήρου.
-Μονάχη έγνοια η γλώσσα μου στις αμμουδιές του Ομήρου.
-
-από το Άξιον Εστί
-του Οδυσσέα Ελύτη
-
-Sîne klâwen durh die wolken sint geslagen,
-er stîget ûf mit grôzer kraft,
-ich sih in grâwen tägelîch als er wil tagen,
-den tac, der im geselleschaft
-erwenden wil, dem werden man,
-den ich mit sorgen în verliez.
-ich bringe in hinnen, ob ich kan.
-sîn vil manegiu tugent michz leisten hiez.
-`)
-
-var containsBenchTestData = []struct {
-	v1     string
-	v2     []byte
-	expect bool
-}{
-	{"abc", []byte("a"), true},
-	{"abc", []byte("b"), true},
-	{"abcdefg", []byte("efg"), true},
-	{"abc", []byte("d"), false},
-	{containsTestText, []byte("стремился"), true},
-	{containsTestText, []byte(containsTestText[10:80]), true},
-	{containsTestText, []byte(containsTestText[100:111]), true},
-	{containsTestText, []byte(containsTestText[len(containsTestText)-100 : len(containsTestText)-10]), true},
-	{containsTestText, []byte(containsTestText[len(containsTestText)-20:]), true},
-	{containsTestText, []byte("notfound"), false},
-}
-
-// some corner cases
-var containsAdditionalTestData = []struct {
-	v1     string
-	v2     []byte
-	expect bool
-}{
-	{"", nil, false},
-	{"", []byte("a"), false},
-	{"a", []byte(""), false},
-	{"", []byte(""), false},
-}
-
 func TestSliceToLower(t *testing.T) {
 	t.Parallel()
 	tests := []struct {
@@ -185,19 +126,6 @@ func TestSliceToLower(t *testing.T) {
 	}
 }
 
-func TestReaderContains(t *testing.T) {
-	c := qt.New(t)
-	for i, this := range append(containsBenchTestData, containsAdditionalTestData...) {
-		result := helpers.ReaderContains(strings.NewReader(this.v1), this.v2)
-		if result != this.expect {
-			t.Errorf("[%d] got %t but expected %t", i, result, this.expect)
-		}
-	}
-
-	c.Assert(helpers.ReaderContains(nil, []byte("a")), qt.Equals, false)
-	c.Assert(helpers.ReaderContains(nil, nil), qt.Equals, false)
-}
-
 func TestGetTitleFunc(t *testing.T) {
 	title := "somewhere over the Rainbow"
 	c := qt.New(t)
@@ -213,18 +141,6 @@ func TestGetTitleFunc(t *testing.T) {
 	c.Assert(helpers.GetTitleFunc("firstupper")(title), qt.Equals, "Somewhere over the Rainbow")
 }
 
-func BenchmarkReaderContains(b *testing.B) {
-
-	for b.Loop() {
-		for i, this := range containsBenchTestData {
-			result := helpers.ReaderContains(strings.NewReader(this.v1), this.v2)
-			if result != this.expect {
-				b.Errorf("[%d] got %t but expected %t", i, result, this.expect)
-			}
-		}
-	}
-}
-
 func TestStringSliceToList(t *testing.T) {
 	for _, tt := range []struct {
 		slice       []string

helpers/path.go

@@ -14,7 +14,6 @@
 package helpers
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -65,22 +64,6 @@ func (p *PathSpec) MakePathSanitized(s string) string {
 	return strings.ToLower(p.MakePath(s))
 }
 
-// MakeTitle converts the path given to a suitable title, trimming whitespace
-// and replacing hyphens with whitespace.
-func MakeTitle(inpath string) string {
-	return strings.Replace(strings.TrimSpace(inpath), "-", " ", -1)
-}
-
-// MakeTitleInPath converts the path given to a suitable title, trimming whitespace
-func MakePathRelative(inPath string, possibleDirectories ...string) (string, error) {
-	for _, currentPath := range possibleDirectories {
-		if after, ok := strings.CutPrefix(inPath, currentPath); ok {
-			return after, nil
-		}
-	}
-	return inPath, errors.New("can't extract relative path, unknown prefix")
-}
-
 // Should be good enough for Hugo.
 var isFileRe = regexp.MustCompile(`.*\..{1,6}$`)
 
@@ -197,29 +180,6 @@ LOOP:
 	return groups
 }
 
-// FindCWD returns the current working directory from where the Hugo
-// executable is run.
-func FindCWD() (string, error) {
-	serverFile, err := filepath.Abs(os.Args[0])
-	if err != nil {
-		return "", fmt.Errorf("can't get absolute path for executable: %v", err)
-	}
-
-	path := filepath.Dir(serverFile)
-	realFile, err := filepath.EvalSymlinks(serverFile)
-	if err != nil {
-		if _, err = os.Stat(serverFile + ".exe"); err == nil {
-			realFile = filepath.Clean(serverFile + ".exe")
-		}
-	}
-
-	if err == nil && realFile != serverFile {
-		path = filepath.Dir(realFile)
-	}
-
-	return path, nil
-}
-
 // Walk walks the file tree rooted at root, calling walkFn for each file or
 // directory in the tree, including root.
 func Walk(fs afero.Fs, root string, walker hugofs.WalkFunc) error {
@@ -235,12 +195,6 @@ func Walk(fs afero.Fs, root string, walker hugofs.WalkFunc) error {
 	return w.Walk()
 }
 
-// SafeWriteToDisk is the same as WriteToDisk
-// but it also checks to see if file/directory already exists.
-func SafeWriteToDisk(inpath string, r io.Reader, fs afero.Fs) (err error) {
-	return afero.SafeWriteReader(fs, inpath, r)
-}
-
 // WriteToDisk writes content to disk.
 func WriteToDisk(inpath string, r io.Reader, fs afero.Fs) (err error) {
 	return afero.WriteReader(fs, inpath, r)

helpers/path_test.go

@@ -109,29 +109,6 @@ func TestMakePathSanitizedDisablePathToLower(t *testing.T) {
 	}
 }
 
-func TestMakePathRelative(t *testing.T) {
-	type test struct {
-		inPath, path1, path2, output string
-	}
-
-	data := []test{
-		{"/abc/bcd/ab.css", "/abc/bcd", "/bbc/bcd", "/ab.css"},
-		{"/abc/bcd/ab.css", "/abcd/bcd", "/abc/bcd", "/ab.css"},
-	}
-
-	for i, d := range data {
-		output, _ := helpers.MakePathRelative(d.inPath, d.path1, d.path2)
-		if d.output != output {
-			t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output)
-		}
-	}
-	_, error := helpers.MakePathRelative("a/b/c.ss", "/a/c", "/d/c", "/e/f")
-
-	if error == nil {
-		t.Errorf("Test failed, expected error")
-	}
-}
-
 func TestGetDottedRelativePath(t *testing.T) {
 	for _, f := range []func(string) string{filepath.FromSlash, func(s string) string { return s }} {
 		doTestGetDottedRelativePath(f, t)
@@ -169,23 +146,6 @@ func doTestGetDottedRelativePath(urlFixer func(string) string, t *testing.T) {
 	}
 }
 
-func TestMakeTitle(t *testing.T) {
-	type test struct {
-		input, expected string
-	}
-	data := []test{
-		{"Make-Title", "Make Title"},
-		{"MakeTitle", "MakeTitle"},
-		{"make_title", "make_title"},
-	}
-	for i, d := range data {
-		output := helpers.MakeTitle(d.input)
-		if d.expected != output {
-			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, output)
-		}
-	}
-}
-
 func TestDirExists(t *testing.T) {
 	type test struct {
 		input    string
@@ -389,70 +349,6 @@ func BenchmarkExtractAndGroupRootPaths(b *testing.B) {
 	}
 }
 
-func TestFindCWD(t *testing.T) {
-	type test struct {
-		expectedDir string
-		expectedErr error
-	}
-
-	// cwd, _ := os.Getwd()
-	data := []test{
-		//{cwd, nil},
-		// Commenting this out. It doesn't work properly.
-		// There's a good reason why we don't use os.Getwd(), it doesn't actually work the way we want it to.
-		// I really don't know a better way to test this function. - SPF 2014.11.04
-	}
-	for i, d := range data {
-		dir, err := helpers.FindCWD()
-		if d.expectedDir != dir {
-			t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedDir, dir)
-		}
-		if d.expectedErr != err {
-			t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedErr, err)
-		}
-	}
-}
-
-func TestSafeWriteToDisk(t *testing.T) {
-	emptyFile := createZeroSizedFileInTempDir(t)
-	tmpDir := t.TempDir()
-
-	randomString := "This is a random string!"
-	reader := strings.NewReader(randomString)
-
-	fileExists := fmt.Errorf("%v already exists", emptyFile.Name())
-
-	type test struct {
-		filename    string
-		expectedErr error
-	}
-
-	now := time.Now().Unix()
-	nowStr := strconv.FormatInt(now, 10)
-	data := []test{
-		{emptyFile.Name(), fileExists},
-		{tmpDir + "/" + nowStr, nil},
-	}
-
-	for i, d := range data {
-		e := helpers.SafeWriteToDisk(d.filename, reader, new(afero.OsFs))
-		if d.expectedErr != nil {
-			if d.expectedErr.Error() != e.Error() {
-				t.Errorf("Test %d failed. Expected error %q but got %q", i, d.expectedErr.Error(), e.Error())
-			}
-		} else {
-			if d.expectedErr != e {
-				t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedErr, e)
-			}
-			contents, _ := os.ReadFile(d.filename)
-			if randomString != string(contents) {
-				t.Errorf("Test %d failed. Expected contents %q but got %q", i, randomString, string(contents))
-			}
-		}
-		reader.Seek(0, 0)
-	}
-}
-
 func TestWriteToDisk(t *testing.T) {
 	emptyFile := createZeroSizedFileInTempDir(t)
 	tmpDir := t.TempDir()

helpers/processing_stats.go

@@ -63,11 +63,6 @@ func (s *ProcessingStats) Incr(counter *uint64) {
 	atomic.AddUint64(counter, 1)
 }
 
-// Add adds an amount to a given counter.
-func (s *ProcessingStats) Add(counter *uint64, amount int) {
-	atomic.AddUint64(counter, uint64(amount))
-}
-
 // ProcessingStatsTable writes a table-formatted representation of stats to w.
 func ProcessingStatsTable(w io.Writer, stats ...*ProcessingStats) {
 	names := make([]string, len(stats)+1)

helpers/url.go

@@ -31,12 +31,6 @@ func (p *PathSpec) URLize(uri string) string {
 	return p.URLEscape(p.MakePathSanitized(uri))
 }
 
-// URLizeFilename creates an URL from a filename by escaping unicode letters
-// and turn any filepath separator into forward slashes.
-func (p *PathSpec) URLizeFilename(filename string) string {
-	return p.URLEscape(filepath.ToSlash(filename))
-}
-
 // URLEscape escapes unicode letters.
 func (p *PathSpec) URLEscape(uri string) string {
 	// escape unicode letters