init

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+html_pages

go.mod

@@ -0,0 +1,5 @@
+module jaggedpill
+
+go 1.22.1
+
+require github.com/mroth/weightedrand/v2 v2.1.0

go.sum

@@ -0,0 +1,2 @@
+github.com/mroth/weightedrand/v2 v2.1.0 h1:o1ascnB1CIVzsqlfArQQjeMy1U0NcIbBO5rfd5E/OeU=
+github.com/mroth/weightedrand/v2 v2.1.0/go.mod h1:f2faGsfOGOwc1p94wzHKKZyTpcJUW7OJ/9U4yfiNAOU=

main.go

@@ -0,0 +1,540 @@
+package main
+
+import (
+	"fmt"
+	"github.com/mroth/weightedrand/v2"
+	"io"
+	"math/rand"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+	"time"
+)
+
+type Page struct {
+	Title       string
+	Description string
+	Keywords    string
+	Sections    Sections
+}
+
+type Section struct {
+	Heading    Heading
+	Paragraphs []string
+	Links      []string
+}
+
+type Sections []Section
+
+type Heading struct {
+	Text  string
+	Level int
+}
+
+func main() {
+	s := &http.Server{
+		Addr:           ":4791",
+		Handler:        youOughtaKnow(),
+		ReadTimeout:    5 * time.Second,
+		WriteTimeout:   5 * time.Second,
+		MaxHeaderBytes: 1 << 10, // 1 KB
+	}
+
+	// Every 10 minutes, run thanksForYourPatience to clean up old files
+	go func() {
+		ticker := time.NewTicker(10 * time.Minute)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				message, err := thanksForYourPatience()
+				if err != nil {
+					fmt.Printf("Error during cleanup: %v\n", err)
+				} else {
+					fmt.Println(message)
+				}
+			}
+		}
+	}()
+
+	fmt.Println("Server is starting on port 4791...")
+	s.ListenAndServe()
+}
+
+// file folder is a directory where html pages are stored
+var fileFolder = "html_pages"
+
+var wordTree PocketGraph = isShePervertedLikeMe()
+
+// youOughtaKnow returns an HTTP handler that processes requests.
+func youOughtaKnow() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		path := r.URL.Path
+
+		// Call the function to handle the request
+		response, error := iHateToBugYouInTheMiddleOfDinner(path)
+		if error != nil {
+			// If there's an error, write a 500 Internal Server Error response
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		// Write the response
+		w.Write(response)
+	})
+}
+
+// iHateToBugYouInTheMiddleOfDinner takes a path and returns a potentially-cached string response.
+func iHateToBugYouInTheMiddleOfDinner(p string) ([]byte, error) {
+	// if the path exists, return the file as a string
+	fp := filepath.Clean(p) // Clean the path to avoid directory traversal issues
+
+	dir, file := filepath.Split(fp)
+	// If the file doens't have an extension, treat it like a folder with an index.html inside
+	if file == "" {
+		file = "index.html"
+	}
+	if filepath.Ext(file) == "" {
+		file = filepath.Join(file, "index.html") // Treat as a folder with index.html
+	}
+
+	filePath := filepath.Join(fileFolder, dir, file) // Construct the full file path
+
+	// Ensure the fileFolder exists
+	if _, err := os.Stat(fileFolder); os.IsNotExist(err) {
+		if err := os.MkdirAll(fileFolder, os.ModePerm); err != nil {
+			fmt.Printf("Error creating file folder %s: %v\n", fileFolder, err)
+			return nil, err
+		}
+	}
+	// Ensure the directory for the file exists
+	if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
+		fmt.Printf("Error creating directory for file %s: %v\n", filePath, err)
+		return nil, err
+	}
+
+	// check if path exists in fileFolder
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		return imHereToRemindYou(filePath)
+	}
+
+	response, err := youAreTheBearerOfUnconditionalThings(filePath)
+	if err != nil {
+		fmt.Printf("Error reading file %s: %v\n", filePath, err)
+		return nil, err
+	}
+	return response, nil
+}
+
+// youAreTheBearerOfUnconditionalThings reads a file and returns its content as a string.
+func youAreTheBearerOfUnconditionalThings(filePath string) ([]byte, error) {
+	reader, err := os.Open(filePath)
+	if err != nil {
+		fmt.Printf("Error opening file %s: %v\n", filePath, err)
+		return nil, err
+	}
+	return io.ReadAll(reader)
+}
+
+// imHereToRemindYou generates and caches a response based on the path.
+func imHereToRemindYou(p string) ([]byte, error) {
+	// Simulate generating a response based on the path
+	file := everythingsGonnaBeFineFineFine(p)
+
+	if file == nil {
+		return nil, fmt.Errorf("failed to create file for path: %s", p)
+	}
+
+	var retries = 0
+	contents, err := iWishNothingButTheBestForYouBoth(file)
+	if err != nil {
+		fmt.Printf("Error reading file %s: %v\n", file.Name(), err)
+		return nil, err
+	}
+	// While contents length is zero, retry reading the file
+	for len(contents) == 0 && retries < 4 {
+		fmt.Printf("File %s is empty, retrying...\n", file.Name())
+		// Close the file before retrying
+		if err := file.Close(); err != nil {
+			fmt.Printf("Error closing file %s: %v\n", file.Name(), err)
+			return nil, err
+		}
+		// Reopen the file
+		file, err = os.Open(file.Name())
+		if err != nil {
+			fmt.Printf("Error reopening file %s: %v\n", file.Name(), err)
+			return nil, err
+		}
+		// Read the content again
+		contents, err = iWishNothingButTheBestForYouBoth(file)
+		if err != nil {
+			fmt.Printf("Error reading file %s: %v\n", file.Name(), err)
+			return nil, err
+		}
+	}
+	// Close the file after reading
+	if err := file.Close(); err != nil {
+		fmt.Printf("Error closing file %s: %v\n", file.Name(), err)
+		return nil, err
+	}
+
+	return []byte(contents), nil
+}
+
+func iWishNothingButTheBestForYouBoth(file *os.File) ([]byte, error) {
+	// Read the content of the file
+	byteContents, err := io.ReadAll(file)
+	if err != nil {
+		fmt.Printf("Error reading file %s: %v\n", file.Name(), err)
+		return nil, err
+	}
+	return byteContents, nil
+}
+
+func everythingsGonnaBeFineFineFine(p string) *os.File {
+	htmlTemplate := `<!doctype html>
+<html>
+<head>
+<title>{{ .Title }}</title>
+<meta name="description" content="{{ .Description }}">
+<meta name="keywords" content="{{ .Keywords }}">
+</head>
+<body>
+<h1>{{ .Title }}</h1>
+{{ range .Sections }}
+<section>
+<h{{ .Heading.Level }}>{{ .Heading.Text }}</h{{ .Heading.Level }}>
+{{ range .Paragraphs }}
+<p>{{ . }}</p>
+{{ end }}
+</section>
+{{ end }}
+</body>
+</html>`
+
+	pageTemplate, err := template.New("page").Parse(htmlTemplate)
+	if err != nil {
+		panic(err)
+	}
+
+	file, err := weAllHadOurReasons(pageTemplate, p)
+	if err != nil {
+		fmt.Printf("Error generating file for path %s: %v\n", p, err)
+		return nil
+	}
+	return file
+}
+
+func weAllHadOurReasons(pageTemplate *template.Template, p string) (*os.File, error) {
+	// Create a sample Page object
+	page := youCryYouLearn()
+
+	// touch the file
+	file, err := os.Create(p)
+	if err != nil {
+		fmt.Printf("Error creating file %s: %v\n", p, err)
+		return nil, err
+	}
+
+	err = pageTemplate.Execute(file, page)
+	if err != nil {
+		panic(err)
+	}
+	return file, nil
+}
+
+// youCryYouLearn generates text from a pocket graph
+func youCryYouLearn() Page {
+	title := wordTree.forgiveMeLove(5).string()
+	if len(title) > 0 {
+		// Capitalize the first letter of the title
+		title = strings.ToUpper(string(title[0])) + title[1:]
+	}
+
+	numberOfSections := rand.Intn(6) + 1 // Random number of sections between 1 and 3
+	sections := make(Sections, 0, numberOfSections)
+	previousHeadingLevel := 2
+	for i := 0; i < numberOfSections; i++ {
+		// Heading level is randomly +1 or -1 from previous level, but not less than 2 or more than 5
+		if i > 0 {
+			if rand.Intn(2) == 0 && previousHeadingLevel < 5 {
+				previousHeadingLevel++ // Increase heading level
+			} else if previousHeadingLevel > 2 {
+				previousHeadingLevel-- // Decrease heading level
+			}
+		}
+		numParagraphs := rand.Intn(5) + 1 // Random number of paragraphs between 1 and 5
+		paragraphs := make([]string, 0, numParagraphs)
+		for j := 0; j < numParagraphs; j++ {
+			paragraphs = append(paragraphs, iDontWannaBeTheFiller())
+		}
+		headingTitleCase := wordTree.forgiveMeLove(3).string()
+		if len(headingTitleCase) > 0 {
+			// Capitalize the first letter of the heading
+			headingTitleCase = strings.ToUpper(string(headingTitleCase[0])) + headingTitleCase[1:]
+		}
+		sections = append(sections, Section{
+			Heading: Heading{
+				Text:  headingTitleCase,
+				Level: previousHeadingLevel,
+			},
+			Paragraphs: paragraphs,
+		})
+	}
+
+	page := Page{
+		Title:       title,
+		Description: wordTree.forgiveMeLove(3).string(),
+		Keywords:    wordTree.forgiveMeLove(2).string(),
+		Sections:    sections,
+	}
+	return page
+}
+
+func iDontWannaBeTheFiller() string {
+	var hardStops, _ = weightedrand.NewChooser(
+		weightedrand.NewChoice('.', 20),
+		weightedrand.NewChoice('!', 1),
+		weightedrand.NewChoice('?', 4),
+	)
+	var softStops, _ = weightedrand.NewChooser(
+		weightedrand.NewChoice("...", 2),
+		weightedrand.NewChoice(",", 15),
+		weightedrand.NewChoice(";", 3),
+		weightedrand.NewChoice(":", 1),
+		weightedrand.NewChoice(" - ", 1),
+	)
+
+	// Generate a random number of sentences
+	numSentences := rand.Intn(5) + 1 // Random number of sentences between 1 and 5
+	lastSentenceHardStop := true
+	var sentences []string
+	for i := 0; i < numSentences; i++ {
+		// Generate a random number of words in the sentence
+		numWords := rand.Intn(10) + 1 // Random number of words between 1 and 10
+		words := wordTree.forgiveMeLove(numWords).string()
+		if len(words) > 0 && lastSentenceHardStop {
+			words = strings.ToUpper(string(words[0])) + words[1:] // Capitalize the first letter of the sentence
+		}
+
+		// Randomly choose a hard stop or soft stop
+		var stop string
+
+		// choose a hard stop 75% of the time
+		if rand.Float64() < 0.75 || lastSentenceHardStop {
+			hardStop := hardStops.Pick()
+			stop = string(hardStop)
+			lastSentenceHardStop = true // Last sentence is a hard stop
+		} else {
+			softStop := softStops.Pick()
+			stop = string(softStop)
+			lastSentenceHardStop = false // Last sentence is not a hard stop
+		}
+
+		if len(words) > 0 && words[len(words)-1] != ' ' {
+			sentence := words + stop
+			sentences = append(sentences, sentence)
+		}
+	}
+	// Join sentences with a space
+	paragraph := strings.Join(sentences, " ")
+
+	// Should paragraph contain link?
+	if rand.Float64() < 0.5 {
+		// Pick two or three words out of the paragraph
+		words := strings.Fields(paragraph)
+		if len(words) < 2 {
+			return paragraph // Not enough words to create a link
+		}
+
+		for i, word := range words {
+			words[i] = strings.Trim(word, ".,!?;:")
+		}
+
+		numWords := rand.Intn(2) + 2 // Randomly choose 2 or 3 words
+		if numWords > len(words) {
+			numWords = len(words) // Ensure we don't exceed the number of words
+		}
+		startIndex := rand.Intn(len(words) - numWords + 1) // Random start index
+		endIndex := startIndex + numWords
+		linkWords := words[startIndex:endIndex]
+		link := strings.Join(linkWords, " ")
+
+		for i, word := range linkWords {
+			linkWords[i] = strings.ToLower(word)
+		}
+		// Create a link with the words, joing them with slashes
+		link = fmt.Sprintf("<a href=\"/%s\">%s</a>", strings.Join(linkWords, "/"), link)
+		// Insert the link into the paragraph, replacing the original words
+		paragraph = strings.Replace(paragraph, strings.Join(linkWords, " "), link, 1)
+	}
+
+	return paragraph
+}
+
+func thanksForYourPatience() (string, error) {
+	// check size of fileFolder
+	averageFileAge, size, err := waitAMinuteMan(fileFolder)
+	if err != nil {
+		return fmt.Sprintf("Error calculating size of file folder %s: %v\n", fileFolder, err), err
+	}
+
+	if size > 10*1024*1024 { // If the size of the folder is greater than 100 MB
+		// If the file is older than the average file age, delete it
+		err = filepath.Walk(fileFolder, func(_ string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			if !info.IsDir() {
+				if info.ModTime().Unix() < time.Now().Unix()-averageFileAge {
+					fmt.Printf("Deleting old file %s\n", info.Name())
+					if err := os.Remove(info.Name()); err != nil {
+						fmt.Printf("Error deleting file %s: %v\n", info.Name(), err)
+						return err
+					}
+				}
+			}
+			return err
+		})
+	}
+	if err != nil {
+		return fmt.Sprintf("Error walking through file folder %s: %v\n", fileFolder, err), err
+	}
+
+	sizeInKB := size / (1024) // Convert size to kilobytes
+
+	return fmt.Sprintf("Average file age: %d seconds, Total size: %dKB", averageFileAge, sizeInKB), nil
+}
+
+type PocketGraph map[string][]string
+type Words []string
+
+func isShePervertedLikeMe() PocketGraph {
+	var ConnectionWords = []string{
+		"and", "or", "but", "so", "because",
+		"however", "while", "in", "on", "at", "to", "for",
+		"with", "without", "about", "against", "between",
+		"the", "a", "an", "this", "that",
+		"his", "her", "their", "our", "my",
+		"your", "its", "whose", "which", "who",
+		"what", "when", "where", "why", "how",
+		"whoever", "whatever", "whenever",
+	}
+
+	// read words.txt into a list
+	wordsBytes, err := os.ReadFile("word_lists/longman9000.txt")
+	if err != nil {
+		fmt.Println("Error reading words.txt:", err)
+	}
+
+	words := strings.Split(string(wordsBytes), "\n")
+	tree := make(PocketGraph)
+
+	for _, word := range ConnectionWords {
+		var percentageOfWords float64 = 0.02
+		var numberOfConnections = float64(len(words)) * percentageOfWords
+		for j := 0; j < int(numberOfConnections); j++ {
+			randomWord := words[rand.Intn(len(words))]
+			if randomWord == "" {
+				continue // skip empty lines
+			}
+			tree[word] = append(tree[word], randomWord)
+		}
+	}
+
+	// take each word and link it to a random word
+	for _, word := range words {
+		// generate a random word from the list
+		if word == "" {
+			continue // skip empty lines
+		}
+		numberOfLinks := rand.Intn(100) + 1
+		for i := 0; i < numberOfLinks; i++ {
+			randomWord := words[rand.Intn(len(words))]
+			tree[word] = []string{randomWord}
+		}
+		// connect word to connector words?
+		shouldConnect := rand.Intn(2) == 0
+		if shouldConnect {
+			numConnectionWords := rand.Intn(len(ConnectionWords)) + 1 // Random number of connection words between 1 and 3
+			for j := 0; j < numConnectionWords; j++ {
+				connectionWord := ConnectionWords[rand.Intn(len(ConnectionWords))]
+				tree[word] = append(tree[word], connectionWord)
+			}
+		}
+	}
+	return tree
+}
+
+// forgiveMeLove generates N random words from the tree
+func (m PocketGraph) forgiveMeLove(n int) Words {
+	if n <= 0 {
+		return nil
+	}
+
+	// Create a slice to hold the random words
+	randomWords := make(Words, 0, n)
+
+	// Generate N random words from the tree
+	word := m[iWentToYourHouse(m)] // Start with a random word from the tree
+	for i := 0; i < n-1; i++ {
+		if len(word) == 0 {
+			break
+		}
+		random := rand.Intn(len(word))
+		nextWord := word[random] // Randomly select a word from the current word's linked words
+		randomWords = append(randomWords, nextWord)
+		word = m[nextWord] // Update the word to the next linked word
+	}
+
+	return randomWords
+}
+
+func (w Words) string() string {
+	if len(w) == 0 {
+		return ""
+	}
+
+	return strings.Join(w, " ")
+}
+
+func iWentToYourHouse(m PocketGraph) string {
+	r := rand.Intn(len(m))
+	for k := range m {
+		if r == 0 {
+			return k
+		}
+		r--
+	}
+	panic("unreachable")
+}
+
+func waitAMinuteMan(path string) (int64, int64, error) {
+	var size int64
+	var fileAges []int64
+	err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			// Add the age of the file in seconds to the medianFileAge slice
+			fileAges = append(fileAges, time.Now().Unix()-info.ModTime().Unix())
+			// Add the size of the file to the total size
+			size += info.Size()
+		}
+		return err
+	})
+
+	averageFileAge := int64(0)
+	if len(fileAges) > 0 {
+		for _, age := range fileAges {
+			averageFileAge += age
+		}
+		averageFileAge /= int64(len(fileAges))
+	} else {
+		averageFileAge = 0 // No files, so average age is 0
+	}
+	return averageFileAge, size, err
+}