gemini-browser

main.go (10400B)

---

 package main
 
 import (
 	"fmt"
 	"github.com/gdamore/tcell/v2"
 	"github.com/makeworld-the-better-one/go-gemini"
 	"github.com/rivo/tview"
 	"io"
 	"net/url"
 	"os"
 	"strconv"
 	"strings"
 )
 
 type Node struct {
 	next  *Node
 	prior *Node
 	url   string
 }
 
 type Site struct {
 	statusCode  int
 	siteContent string
 	url         string
 }
 
 type Link struct {
 	address   string
 	plaintext string
 }
 
 var (
 	// TODO: Possibly replace this with a cache; it will be annoying to persist the page position
 	// but it's nice to have that when traversing links
 
 	// TODO: There also seems to be some other form of state that messes with history traversal. 
 
 	history           *Node
 	// TODO: Refactor to only store state in the container
 	linkSelectionText string
 	links             []Link
 	site              Site
 	linkFollowMode    bool
 	linkFollowRendered bool
 	showInputBox      bool
 	inputBoxRendered  bool
 	userInputBox      *tview.InputField
 	userInputPrefix	  string
 	mainArea          *tview.Flex
 	mainText          *tview.TextView
 	entryText         *tview.TextView
 	app               *tview.Application
 )
 
 func stripLeadingWhiteSpace(text string) string {
 
 	for len(text) > 0 {
 		if text[0] == ' ' || text[0] == '\t' {
 			if len(text) > 1 {
 				text = text[1:]
 			} else {
 				text = ""
 				return text
 			}
 		} else {
 			return text
 		}
 	}
 
 	return text
 }
 
 // TODO: Handle redirects
 // seems like most clients prompt before redirects
 // I'd want prompts prior to redirects cross-origin
 
 // TODO: Should reuse node pass in a node to remove side effect of global state?
 func updateSite(newUrl string, reuseNode bool) error {
 
 	client := &gemini.Client{}
 
 	resp, err := client.Fetch(newUrl)
 
 	if err != nil {
 		return err
 	}
 
 	defer resp.Body.Close()
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 
 	if err != nil {
 		return err
 	}
 
 	site.statusCode = resp.Status
 
 	// if statuscode // 10 == 1; show popup for user interaction per 1x status code specification
 	// TODO: Make this better. Technically, the spec states that status code 10 is for 
 	// inputs and 11 **should** behave like a password field with input masked (emphasis on should)
 	// so per rfc specifications I don't have to.
 	// So maybe we should special case both of them to support this and make sure other status codes,
 	// once we have full coverage are errored?
 
 	// TODO: When giving an invalid link to tlgs.one to add to the index it seems to redirect
 	// to another input site which doesn't seem to work correctly. 
 
 	if site.statusCode >= 10 && site.statusCode < 20 {
 		showInputBox = true
 		site.url = newUrl
 		userInputPrefix = resp.Meta + ": "
 		return nil
 	} else {
 		showInputBox = false
 	}
 
 	body := string(bodyBytes)
 
 	if !reuseNode {
 		newNode := &Node{url: newUrl}
 		if history != nil {
 			history.next = newNode
 			newNode.prior = history
 		}
 
 		history = newNode
 	}
 
 	// TODO: Should be done once the site text is updated
 	site.url = newUrl
 
 	totalLinkCount := CountLinks(body)
 	lines := strings.Split(body, "\n")
 
 	escaped := false
 	escape := "```"
 
 	result := ""
 	linkCount := 0
 
 	links = []Link{}
 
 	// this should never happen because we already
 	// loaded this site and all that
 	u, err := url.Parse(newUrl)
 
 	if err != nil {
 		panic(err)
 	}
 
 	for _, item := range lines {
 
 		inserted := false
 
 		if len(item) >= 3 && strings.Compare(escape, item[:3]) == 0 {
 			escaped = !escaped
 		}
 
 		if len(item) > 3 && !escaped {
 			if item[0] == '=' && item[1] == '>' {
 
 				link := Link{}
 				s := stripLeadingWhiteSpace(item[2:])
 
 				parts := strings.FieldsFunc(s, func(r rune) bool {
 					return r == ' ' || r == '\t'
 				})
 
 				address := ""
 				text := ""
 
 				if len(parts) > 0 {
 					address = parts[0]
 				}
 				if len(parts) > 1 {
 					text = strings.Join(parts[1:], " ")
 				}
 
 				newLn, err := url.Parse(address)
 
 				if err != nil {
 					// invalid url on this site...
 					// that's their fucking fault, leave it as is
 					link.address = address
 				} else {
 					link.address = u.ResolveReference(newLn).String()
 				}
 
 				link.plaintext = strings.TrimSpace(sanitized(text))
 
 				links = append(links, link)
 
 				inserted = true
 
 				spacer := " "
 				if totalLinkCount >= 10 && linkCount < 10 {
 					spacer = "  "
 				}
 
 				if link.plaintext != "" {
 					result += fmt.Sprintf("[%d]%s=> %s", linkCount, spacer, link.plaintext)
 				} else {
 					// grr.... sanitizing the link fucks stuff up in terms of conssitency
 					result += fmt.Sprintf("[%d]%s=> %s", linkCount, spacer, sanitized(link.address))
 				}
 
 				linkCount += 1
 			}
 		}
 
 		if !inserted {
 			result += sanitized(item)
 		}
 
 		result += "\n"
 
 	}
 
 	site.siteContent = result
 	// TODO: Is there a way to persist this across history for niceness e.g. seek line you were on before?
 	mainText.ScrollToBeginning()
 	return nil
 }
 
 // This will only render ascii. Anything beyond this shouldn't be assumed to work in a conventional terminal
 // Emojis don't work in st.
 
 // Yes, this does break international support; consider patching if you want, but this broke st trying to
 // re-render stuff, could be a limit of the combination of st and tview.
 
 func sanitized(s string) string {
 	var b strings.Builder
 
 	for _, r := range s {
 		if r <= 0x7F {
 			b.WriteRune(r)
 		}
 	}
 
 	return b.String()
 
 }
 
 func initApplication() *tview.Application {
 	app := tview.NewApplication()
 	return app
 }
 
 func repaint() {
 	app.QueueUpdateDraw(func() {
 		mainArea.SetTitle(site.url)
 		mainText.SetText(site.siteContent)
 		
 		if linkFollowMode {
 			// TODO: Refactor to only store state in the container.
 			entryText.SetText("Link to follow: " + linkSelectionText)
 			if linkFollowRendered == false {
 				mainArea.AddItem(entryText, 1, 0, false)
 				linkFollowRendered = true
 			}
 		} else {
 			mainArea.RemoveItem(entryText)
 			linkFollowRendered = false
 
 			entryText.SetText("")
 		}
 
 		if showInputBox {
 
 			if inputBoxRendered == false {
 				mainArea.AddItem(userInputBox, 1, 0, false)
 				inputBoxRendered = true
 			}
 			app.SetFocus(userInputBox)
 
 			// TODO: This is janky. Would it be possible to just have another on screen element?
 			if !strings.HasPrefix(userInputBox.GetText(), userInputPrefix) {
 				userInputBox.SetText(userInputPrefix)
 			}
 
 		} else {
 			inputBoxRendered = false
 			mainArea.RemoveItem(userInputBox)
 			app.SetRoot(mainArea, true).SetFocus(mainArea)
 		}
 
 	})
 }
 
 func main() {
 
 	app = initApplication()
 	mainText = tview.NewTextView()
 	mainText.SetBackgroundColor(tcell.ColorDefault)
 
 	// TODO: This should be an input field probably
 	entryText = tview.NewTextView()
 
 	mainArea = tview.NewFlex().SetDirection(tview.FlexRow)
 	mainArea.SetBorder(true)
 
 	userInputBox = tview.NewInputField()
 	// this is to be consistent with the otherbackground thing. 
 	// TODO: Should this be a constant color definition?
 	userInputBox.SetFieldBackgroundColor(tview.Styles.PrimitiveBackgroundColor)
 
 	mainArea.AddItem(mainText, 0, 1, true)
 
 
 	entryText.SetText("")
 
 	initSite := "gemini://tlgs.one/known-hosts"
 
 	if len(os.Args) > 1 {
 		initSite = os.Args[1]
 	}
 
 	go func() {
 		err := updateSite(initSite, false)
 
 		if err != nil {
 			app.Stop()
 			panic(err)
 		}
 		repaint()
 	}()
 
 	mainArea.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
 		go func() {
 
 			// TODO: There is a really annoying bug where some stuff is slow to load
 			// and this will cause elements on screen to hide but not be obvious stuff is loading
 			// this messes with state expectations wherein multiple pages can be loaded from the same base. 
 			// presumably this could cause some weird races...
 			if event.Key() == tcell.KeyEnter {
 				if linkFollowMode {
 					selection, err := strconv.Atoi(linkSelectionText)
 
 					if err == nil {
 						if selection < len(links) {
 							// TODO: Handle this possible error
 							updateSite(links[selection].address, false)
 						}
 					}
 
 					linkFollowMode = false
 					linkSelectionText = ""
 				}
 
 				if showInputBox {
 					text := userInputBox.GetText()
 					text = strings.TrimPrefix(text, userInputPrefix)
 					if strings.Compare(text, "") != 0 {
 						// url parse
 						urlEncoded, _ := url.Parse(text)
 						text = urlEncoded.String()
 
 
 						// TODO: This is really janky.
 						// like the remove / add stuff is awful. Should manage state better.
 						inputBoxRendered = false
 						showInputBox = false
 
 						repaint()
 
 						updateSite(site.url + "?" + text, false)
 						userInputBox.SetText("")
 					}
 				}
 
 			}
 
 			if event.Key() == tcell.KeyBackspace || event.Key() == tcell.KeyBackspace2 {
 				if linkFollowMode {
 					if len(linkSelectionText) > 0 {
 						linkSelectionText = linkSelectionText[:len(linkSelectionText)-1]
 					}
 				}
 			}
 
 			if event.Key() == tcell.KeyEsc {
 				if linkFollowMode {
 					linkFollowMode = false
 					linkSelectionText = ""
 				}
 				if showInputBox {
 					showInputBox = false
 					inputBoxRendered = false
 					// Text tracks the state of the element.
 					userInputBox.SetText("")
 				}
 			
 			}
 
 			r := event.Rune()
 
 			// TODO: Refactor this. This is shit. Use the component to store the state with 
 			// gettext and settext.
 
 			if r == '0' || r == '1' || r == '2' || r == '3' || r == '4' || r == '5' || r == '6' || r == '7' || r == '8' || r == '9'{
 				if linkFollowMode {
 					linkSelectionText += string(r)
 				}
 			}
 
 			if r == 'b' {
 				if history != nil && history.prior != nil && history.prior.url != "" {
 					history = history.prior
 					target := history.url
 					// TODO: handle this possible error
 					updateSite(target, true)
 				}
 			}
 
 			if r == 'f' {
 				if history != nil && history.next != nil && history.next.url != "" {
 					history = history.next
 					target := history.url
 					// TODO: handle this possible error
 					updateSite(target, true)
 				}
 			}
 
 			if event.Rune() == ' ' && !showInputBox {
 				linkFollowMode = true
 			}
 
 			// It's always safe to repaint; the entire state is stored globally, nothing is
 			// stored in components
 
 			repaint()
 		}()
 
 		return event
 	})
 
 	app.SetRoot(mainArea, true).SetFocus(mainArea)
 
 	err := app.Run()
 
 	if err != nil {
 		panic(err)
 	}
 }
 
 func CountLinks(body string) int {
 	lines := strings.Split(body, "\n")
 	count := 0
 
 	escaped := false
 	escape := "```"
 
 	for _, item := range lines {
 		if len(item) >= 3 && strings.Compare(escape, item[:3]) == 0 {
 			escaped = !escaped
 		}
 
 		if len(item) > 3 && !escaped {
 			if item[0] == '=' && item[1] == '>' {
 				count += 1
 			}
 		}
 
 	}
 
 	return count
 }